@prisma-next/target-sqlite 0.14.0 → 0.15.0-dev.10

package/src/core/migrations/op-factory-call.ts

@@ -96,6 +96,11 @@ function renderDdlConstraintAsTsCall(constraint: DdlTableConstraint): string {
       const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
       return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
     }
+    case 'check-expression':
+      throw new Error(
+        `SQLite does not support expression CHECK constraints (constraint "${constraint.name}"). ` +
+          'Scalar-array columns and their element-non-null checks are Postgres-only.',
+      );
   }
 }
 

package/src/core/migrations/operations/shared.ts

@@ -60,7 +60,6 @@ export interface SqliteForeignKeySpec {
   readonly name?: string;
   readonly onDelete?: ReferentialAction;
   readonly onUpdate?: ReferentialAction;
-  readonly constraint: boolean;
 }
 
 /**
@@ -103,12 +102,11 @@ export function renderColumnDefinition(column: SqliteColumnSpec): string {
 
 /**
  * Renders an inline FOREIGN KEY constraint clause for a `CREATE TABLE`
- * body. Returns the empty string when `constraint` is false (the FK is
- * tracked at the contract level for index-creation purposes only and must
- * not produce DDL).
+ * body. Every `SqliteForeignKeySpec` is constraint-bearing by construction
+ * (`tableSpecFromNode` only ever builds specs from schema-IR FK nodes, which
+ * are themselves constraint-only — a non-constraint FK contributes no node).
  */
 export function renderForeignKeyClause(fk: SqliteForeignKeySpec): string {
-  if (!fk.constraint) return '';
   const name = fk.name ? `CONSTRAINT ${quoteIdentifier(fk.name)} ` : '';
   let sql = `${name}FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(', ')}) REFERENCES ${quoteIdentifier(fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(', ')})`;
   if (fk.onDelete !== undefined) {

package/src/core/migrations/operations/tables.ts

@@ -1,6 +1,9 @@
 import type { MigrationOperationClass } from '@prisma-next/family-sql/control';
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
-import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
+import { issueOutcome } from '@prisma-next/framework-components/control';
+import { RelationalSchemaNodeKind, type SqlColumnIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { tableExistsAst } from '../../../contract-free/checks';
 import { stripOuterParens } from '../../default-normalizer';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
@@ -109,7 +112,7 @@ export interface RecreateTableArgs {
   /**
    * Per-issue postcheck steps appended after the structural postchecks. The
    * planner pre-builds these via `buildRecreatePostchecks` so the call IR
-   * carries flat, serializable data only — no `SchemaIssue` references.
+   * carries flat, serializable data only — no `SchemaDiffIssue` references.
    */
   readonly postchecks: readonly { readonly description: string; readonly sql: string }[];
   readonly operationClass: MigrationOperationClass;
@@ -195,33 +198,37 @@ export async function recreateTable(
 }
 
 /**
- * Build a one-line summary of a recreate-table operation from the schema
+ * Build a one-line summary of a recreate-table operation from the schema-diff
  * issues that triggered it. Lives next to `recreateTable` so the planner
  * (which has the issues) can produce the same description the factory
  * used to build inline. Keeping the formatting target-side keeps
- * `RecreateTableCall` issue-free at the IR layer.
+ * `RecreateTableCall` issue-free at the IR layer. `SchemaDiffIssue` carries
+ * no rendered message, so this renders one from each issue's path.
  */
-export function buildRecreateSummary(tableName: string, issues: readonly SchemaIssue[]): string {
-  const messages = issues.map((i) => i.message).join('; ');
+export function buildRecreateSummary(
+  tableName: string,
+  issues: readonly SchemaDiffIssue[],
+): string {
+  const messages = issues.map((i) => i.path.join('/')).join('; ');
   return `Recreates table ${tableName} to apply schema changes: ${messages}`;
 }
 
-const COLUMN_LEVEL_ISSUE_KINDS = new Set<SchemaIssue['kind']>([
-  'nullability_mismatch',
-  'default_mismatch',
-  'default_missing',
-  'extra_default',
-  'type_mismatch',
-]);
-
-const PK_ISSUE_KINDS = new Set<SchemaIssue['kind']>(['primary_key_mismatch', 'extra_primary_key']);
-
-const UNIQUE_ISSUE_KINDS = new Set<SchemaIssue['kind']>([
-  'unique_constraint_mismatch',
-  'extra_unique_constraint',
-]);
+function nodeKindOf(issue: SchemaDiffIssue): string | undefined {
+  const node = issue.expected ?? issue.actual;
+  if (node === undefined) return undefined;
+  return blindCast<{ readonly nodeKind: string }, 'every diff-tree node declares nodeKind'>(node)
+    .nodeKind;
+}
 
-const FK_ISSUE_KINDS = new Set<SchemaIssue['kind']>(['foreign_key_mismatch', 'extra_foreign_key']);
+/** Mirrors `SqlColumnIR.isEqualTo`'s type comparison, isolated so a `not-equal` column issue's postcheck can target type drift and nullability drift independently. */
+function columnTypeChanged(expected: SqlColumnIR, actual: SqlColumnIR): boolean {
+  if (expected.resolvedNativeType !== undefined && actual.resolvedNativeType !== undefined) {
+    return expected.resolvedNativeType !== actual.resolvedNativeType;
+  }
+  return (
+    expected.nativeType !== actual.nativeType || Boolean(expected.many) !== Boolean(actual.many)
+  );
+}
 
 /**
  * Returns the columns the contract expects as the table's primary key. Picks
@@ -238,50 +245,97 @@ function quoteSqlList(values: readonly string[]): string {
   return values.map((v) => `'${escapeLiteral(v)}'`).join(', ');
 }
 
+function columnNameFromNode(issue: SchemaDiffIssue): string | undefined {
+  const node = issue.expected ?? issue.actual;
+  if (node === undefined) return undefined;
+  return blindCast<
+    { readonly name: string },
+    'a column or column-default issue node carries name (default nodes read the owning column name off the diff path instead)'
+  >(node).name;
+}
+
+/**
+ * A column-default issue's own node has no back-reference to its owning
+ * column — it's a transient child built by `SqlColumnIR.children()`. The
+ * column's id (`column:<name>`) is always the diff path's second-to-last
+ * segment for a default issue (`[..., tableId, columnId, 'default']`), so
+ * the name is recovered from the path rather than the node.
+ */
+function columnNameFromDefaultIssuePath(issue: SchemaDiffIssue): string | undefined {
+  const columnId = issue.path[issue.path.length - 2];
+  if (columnId === undefined) return undefined;
+  const prefix = 'column:';
+  return columnId.startsWith(prefix) ? columnId.slice(prefix.length) : columnId;
+}
+
 /**
  * Per-issue postchecks verifying the recreated table's shape against the
- * contract spec. Column-level issues (`nullability_mismatch`,
- * `default_mismatch`, …) emit one targeted check each; constraint-level
- * issues (`primary_key_mismatch`, `unique_constraint_mismatch`,
- * `foreign_key_mismatch`, plus their `extra_*` siblings) emit one
- * `pragma_*`-driven check per declared constraint in the contract spec, so
- * a recreated table with the right columns but the wrong PK / unique / FK
- * shape fails the postcheck instead of passing silently. Exported so the
- * planner can pre-build the list at construction time and
- * `RecreateTableCall` doesn't have to carry `SchemaIssue` objects through
+ * expected spec. Column-level issues (`sql-column` `not-equal`,
+ * `sql-column-default` any reason) emit one targeted check each;
+ * constraint-level issues (`sql-primary-key`, `sql-unique`, `sql-foreign-key`,
+ * any reason) emit one `pragma_*`-driven check per declared constraint in the
+ * expected spec, so a recreated table with the right columns but the wrong
+ * PK / unique / FK shape fails the postcheck instead of passing silently.
+ * Exported so the planner can pre-build the list at construction time and
+ * `RecreateTableCall` doesn't have to carry `SchemaDiffIssue` objects through
  * to render time.
  */
 export function buildRecreatePostchecks(
   tableName: string,
-  issues: readonly SchemaIssue[],
+  issues: readonly SchemaDiffIssue[],
   spec: SqliteTableSpec,
 ): Array<{ description: string; sql: string }> {
   const checks: Array<{ description: string; sql: string }> = [];
   const t = escapeLiteral(tableName);
   const byName = new Map(spec.columns.map((c) => [c.name, c]));
 
+  let hasPkIssue = false;
+  let hasUniqueIssue = false;
+  let hasFkIssue = false;
+
   for (const issue of issues) {
-    if (issue.kind === 'enum_values_changed') continue;
-    if (!COLUMN_LEVEL_ISSUE_KINDS.has(issue.kind)) continue;
-    if (!issue.column) continue;
-    const c = escapeLiteral(issue.column);
-    if (issue.kind === 'nullability_mismatch') {
-      // `expected` carries the contract's nullable flag as a string. We only
-      // emit a postcheck when the value is recognized — anything else
-      // (case-folded, numeric coding, etc.) is left to the structural
-      // verifier so a typo here can't silently invert the meaning.
-      let wantNotNull: boolean | undefined;
-      if (issue.expected === 'false') wantNotNull = true;
-      else if (issue.expected === 'true') wantNotNull = false;
-      if (wantNotNull !== undefined) {
+    const nodeKind = nodeKindOf(issue);
+    if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === 'not-equal') {
+      const columnName = columnNameFromNode(issue);
+      if (columnName === undefined) continue;
+      const c = escapeLiteral(columnName);
+      const expected = blindCast<SqlColumnIR, 'a not-equal column issue carries the expected node'>(
+        issue.expected,
+      );
+      const actual = blindCast<SqlColumnIR, 'a not-equal column issue carries the actual node'>(
+        issue.actual,
+      );
+      if (expected.nullable !== actual.nullable) {
         checks.push({
-          description: `verify "${issue.column}" nullability on "${tableName}"`,
-          sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${wantNotNull ? 1 : 0}`,
+          description: `verify "${columnName}" nullability on "${tableName}"`,
+          sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${expected.nullable ? 0 : 1}`,
         });
       }
+      if (columnTypeChanged(expected, actual)) {
+        const colSpec = byName.get(columnName);
+        if (colSpec) {
+          checks.push({
+            description: `verify "${columnName}" type on "${tableName}"`,
+            sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND LOWER(type) = '${escapeLiteral(colSpec.typeSql.toLowerCase())}'`,
+          });
+        }
+      }
+      continue;
     }
-    if (issue.kind === 'default_mismatch' || issue.kind === 'default_missing') {
-      const colSpec = byName.get(issue.column);
+    if (nodeKind === RelationalSchemaNodeKind.columnDefault) {
+      const columnName = columnNameFromDefaultIssuePath(issue);
+      if (columnName === undefined) continue;
+      const c = escapeLiteral(columnName);
+      if (issueOutcome(issue) === 'not-expected') {
+        checks.push({
+          description: `verify "${columnName}" has no default on "${tableName}"`,
+          sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value IS NULL`,
+        });
+        continue;
+      }
+      // not-found (missing) or not-equal (drift) — both want the expected
+      // default SQL present on the live column.
+      const colSpec = byName.get(columnName);
       const expectedRaw = colSpec?.defaultSql.startsWith('DEFAULT ')
         ? // SQLite's pragma_table_info.dflt_value strips outer parens for
           // expression defaults (per the SQLite docs), so `(datetime('now'))`
@@ -291,34 +345,20 @@ export function buildRecreatePostchecks(
         : null;
       if (expectedRaw) {
         checks.push({
-          description: `verify "${issue.column}" default on "${tableName}"`,
+          description: `verify "${columnName}" default on "${tableName}"`,
           sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value = '${escapeLiteral(expectedRaw)}'`,
         });
       }
+      continue;
     }
-    if (issue.kind === 'type_mismatch') {
-      const colSpec = byName.get(issue.column);
-      if (colSpec) {
-        checks.push({
-          description: `verify "${issue.column}" type on "${tableName}"`,
-          sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND LOWER(type) = '${escapeLiteral(colSpec.typeSql.toLowerCase())}'`,
-        });
-      }
-    }
-    if (issue.kind === 'extra_default') {
-      checks.push({
-        description: `verify "${issue.column}" has no default on "${tableName}"`,
-        sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND dflt_value IS NULL`,
-      });
-    }
+    if (nodeKind === RelationalSchemaNodeKind.primaryKey) hasPkIssue = true;
+    if (nodeKind === RelationalSchemaNodeKind.unique) hasUniqueIssue = true;
+    if (nodeKind === RelationalSchemaNodeKind.foreignKey) hasFkIssue = true;
   }
 
   // Constraint-level issues — emit one postcheck per declared constraint in
-  // the contract spec when *any* issue of that kind fires, since recreate
+  // the expected spec when *any* issue of that kind fires, since recreate
   // rebuilds the entire table at once.
-  const hasPkIssue = issues.some((i) => PK_ISSUE_KINDS.has(i.kind));
-  const hasUniqueIssue = issues.some((i) => UNIQUE_ISSUE_KINDS.has(i.kind));
-  const hasFkIssue = issues.some((i) => FK_ISSUE_KINDS.has(i.kind));
 
   if (hasPkIssue) {
     const pkColumns = expectedPrimaryKeyColumns(spec);

package/src/core/migrations/planner-strategies.ts

@@ -1,88 +1,53 @@
 /**
  * SQLite migration strategies.
  *
- * Each strategy examines the issue list, consumes issues it handles, and
- * returns the `SqliteOpFactoryCall[]` to address them. The issue planner
- * runs each strategy in order and routes whatever's left through
- * `mapIssueToCall`.
+ * Each strategy examines the node-typed issue list, consumes issues it
+ * handles, and returns the `SqliteOpFactoryCall[]` to address them. The issue
+ * planner runs each strategy in order and routes whatever's left through
+ * `mapNodeIssueToCall`.
  *
  * SQLite has no enums, no data-safe backfill, and no component-declared
  * database dependencies. The only recipe that needs strategy-level
- * multi-issue consumption is `recreateTable` (added in a later phase), which
- * absorbs type/nullability/default/constraint mismatches for a given table
- * into a single recreate operation.
+ * multi-issue consumption is `recreateTable`, which absorbs
+ * type/nullability/default/constraint mismatches for a given table into a
+ * single recreate operation.
  */
 
-import type { Contract } from '@prisma-next/contract/types';
 import type {
-  CodecControlHooks,
   MigrationOperationClass,
   MigrationOperationPolicy,
 } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
-import type { SchemaIssue } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import type {
-  SqlStorage,
-  StorageTable,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
+import { issueOutcome } from '@prisma-next/framework-components/control';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
-import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
-import { toTableSpec } from './issue-planner';
+import {
+  RelationalSchemaNodeKind,
+  type SqlColumnIR,
+  type SqlSchemaIR,
+} from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { columnTypeChanged, tableSpecFromNode } from './issue-planner';
 import { DataTransformCall, RecreateTableCall, type SqliteOpFactoryCall } from './op-factory-call';
 import type { SqliteIndexSpec } from './operations/shared';
 import { buildRecreatePostchecks, buildRecreateSummary } from './operations/tables';
 
 export interface StrategyContext {
-  readonly toContract: Contract<SqlStorage>;
-  readonly fromContract: Contract<SqlStorage> | null;
-  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
-  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;
-  readonly schema: SqlSchemaIR;
+  /** The desired ("end") tree — resolved leaf values, incl. `codecRef`. */
+  readonly expected: SqlSchemaIR;
+  /** The live ("start") tree. */
+  readonly actual: SqlSchemaIR;
   readonly policy: MigrationOperationPolicy;
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
 }
 
-/**
- * Look up a storage table by its explicit namespace coordinate. Returns
- * `undefined` when the namespace has no table by that name (or no such
- * namespace exists). Callers that get `undefined` MUST treat it as an
- * explicit conflict rather than silently falling back to a name-only
- * walk across namespaces — the SQLite target currently has a single
- * namespace, but this helper enforces the explicit-coordinate
- * discipline so a future multi-namespace SQLite shape inherits the
- * conflict-on-stale-coordinate behaviour the Postgres planner already
- * has.
- */
-export function tableAt(
-  storage: SqlStorage,
-  namespaceId: string,
-  tableName: string,
-): StorageTable | undefined {
-  const ns = storage.namespaces[namespaceId];
-  return ns !== undefined ? ns.entries.table?.[tableName] : undefined;
-}
-
-/**
- * Default namespace coordinate for an issue that does not carry one
- * explicitly. Hand-crafted unit-test issues fall back to `__unbound__`,
- * the only namespace any single-namespace contract carries —
- * verifier-emitted issues for legacy single-namespace contracts already
- * stamp this id explicitly. Typed structurally so issue variants
- * without a `namespaceId` slot flow through to the same fallback.
- */
-export function resolveNamespaceIdForIssue(issue: { readonly namespaceId?: string }): string {
-  return issue.namespaceId ?? UNBOUND_NAMESPACE_ID;
-}
-
 export type CallMigrationStrategy = (
-  issues: readonly SchemaIssue[],
+  issues: readonly SchemaDiffIssue[],
   context: StrategyContext,
 ) =>
   | {
       kind: 'match';
-      issues: readonly SchemaIssue[];
+      issues: readonly SchemaDiffIssue[];
       calls: readonly SqliteOpFactoryCall[];
       recipe?: boolean;
     }
@@ -92,60 +57,77 @@ export type CallMigrationStrategy = (
 // Recreate-table strategy
 // ============================================================================
 
-const WIDENING_ISSUE_KINDS = new Set<SchemaIssue['kind']>(['default_mismatch', 'default_missing']);
-
-const DESTRUCTIVE_ISSUE_KINDS = new Set<SchemaIssue['kind']>([
-  'extra_default',
-  'type_mismatch',
-  'primary_key_mismatch',
-  'foreign_key_mismatch',
-  'unique_constraint_mismatch',
-  'extra_foreign_key',
-  'extra_unique_constraint',
-  'extra_primary_key',
-]);
-
-function classifyIssue(issue: SchemaIssue): 'widening' | 'destructive' | null {
-  if (issue.kind === 'enum_values_changed') return null;
-  if (!issue.table) return null;
-  if (issue.kind === 'nullability_mismatch') {
-    // Relaxing (NOT NULL → nullable) is widening; tightening is destructive.
-    return issue.expected === 'true' ? 'widening' : 'destructive';
+/**
+ * Classifies a node issue into the operation class a recreate absorbing it
+ * would need, or `null` when the strategy doesn't handle this node/reason at
+ * all (table/column not-found-or-not-expected, and index issues — those are
+ * standalone ops, never folded into a recreate).
+ *
+ * Column drift is a single `not-equal` issue now (type AND nullability
+ * compared together by `SqlColumnIR.isEqualTo`), so this reads both fields
+ * off the node pair directly rather than trusting a separate issue kind per
+ * attribute: a type change is always destructive; a pure nullability change
+ * is destructive when tightening (NOT NULL required) and widening when
+ * relaxing.
+ */
+function classifyNodeIssue(issue: SchemaDiffIssue): 'widening' | 'destructive' | null {
+  const node = issue.expected ?? issue.actual;
+  if (node === undefined) return null;
+  const nodeKind = blindCast<
+    { readonly nodeKind: string },
+    'every diff-tree node declares nodeKind'
+  >(node).nodeKind;
+  switch (nodeKind) {
+    case RelationalSchemaNodeKind.column: {
+      if (issueOutcome(issue) !== 'not-equal') return null;
+      const expected = blindCast<SqlColumnIR, 'a not-equal column issue carries the expected node'>(
+        issue.expected,
+      );
+      const actual = blindCast<SqlColumnIR, 'a not-equal column issue carries the actual node'>(
+        issue.actual,
+      );
+      if (columnTypeChanged(expected, actual)) return 'destructive';
+      // Type is unchanged, so `not-equal` here means only nullability
+      // differs: relaxing (NOT NULL → nullable) is safe; tightening is not.
+      return expected.nullable ? 'widening' : 'destructive';
+    }
+    case RelationalSchemaNodeKind.columnDefault:
+      return issueOutcome(issue) === 'not-expected' ? 'destructive' : 'widening';
+    case RelationalSchemaNodeKind.primaryKey:
+    case RelationalSchemaNodeKind.foreignKey:
+    case RelationalSchemaNodeKind.unique:
+      return 'destructive';
+    default:
+      return null;
   }
-  if (WIDENING_ISSUE_KINDS.has(issue.kind)) return 'widening';
-  if (DESTRUCTIVE_ISSUE_KINDS.has(issue.kind)) return 'destructive';
-  return null;
 }
 
 /**
  * Groups recreate-eligible issues by table, decides per-table operation class
  * (destructive wins over widening), and emits one `RecreateTableCall` per
  * table. Returns unchanged-or-smaller issue list — issues the strategy
- * consumed are removed so `mapIssueToCall` doesn't double-handle them.
+ * consumed are removed so `mapNodeIssueToCall` doesn't double-handle them.
+ *
+ * The full desired/live table shapes come from `ctx.expected`/`ctx.actual`
+ * directly (keyed by table name — SQLite is a flat, single-namespace target)
+ * rather than from any individual issue, since a single drifted attribute's
+ * issue only carries that attribute's own node, never the whole table.
  */
 export const recreateTableStrategy: CallMigrationStrategy = (issues, ctx) => {
-  const byTable = new Map<
-    string,
-    { issues: SchemaIssue[]; hasDestructive: boolean; namespaceId: string }
-  >();
-  const consumed = new Set<SchemaIssue>();
+  const byTable = new Map<string, { issues: SchemaDiffIssue[]; hasDestructive: boolean }>();
+  const consumed = new Set<SchemaDiffIssue>();
 
   for (const issue of issues) {
-    const cls = classifyIssue(issue);
+    const cls = classifyNodeIssue(issue);
     if (!cls) continue;
-    if (issue.kind === 'enum_values_changed') continue;
-    if (!issue.table) continue;
-    const table = issue.table;
-    const entry = byTable.get(table);
+    const tableName = issue.path[1];
+    if (tableName === undefined) continue;
+    const entry = byTable.get(tableName);
     if (entry) {
       entry.issues.push(issue);
       if (cls === 'destructive') entry.hasDestructive = true;
     } else {
-      byTable.set(table, {
-        issues: [issue],
-        hasDestructive: cls === 'destructive',
-        namespaceId: resolveNamespaceIdForIssue(issue),
-      });
+      byTable.set(tableName, { issues: [issue], hasDestructive: cls === 'destructive' });
     }
     consumed.add(issue);
   }
@@ -154,44 +136,29 @@ export const recreateTableStrategy: CallMigrationStrategy = (issues, ctx) => {
 
   const calls: SqliteOpFactoryCall[] = [];
   for (const [tableName, entry] of byTable) {
-    const contractTable = tableAt(ctx.toContract.storage, entry.namespaceId, tableName);
-    const schemaTable = ctx.schema.tables[tableName];
-    if (!contractTable || !schemaTable) continue;
+    const expectedTable = ctx.expected.tables[tableName];
+    const actualTable = ctx.actual.tables[tableName];
+    if (!expectedTable || !actualTable) continue;
     const operationClass: MigrationOperationClass = entry.hasDestructive
       ? 'destructive'
       : 'widening';
 
-    // Flatten the contract table to a self-contained spec — the Call holds
-    // pre-rendered SQL fragments only, no `StorageColumn` or `storageTypes`.
-    const tableSpec = toTableSpec(contractTable, ctx.storageTypes);
+    // Flatten the expected table node to a self-contained spec — the Call
+    // holds pre-rendered SQL fragments only, no schema-IR node.
+    const tableSpec = tableSpecFromNode(expectedTable);
 
-    const seenIndexColumnKeys = new Set<string>();
-    const indexes: SqliteIndexSpec[] = [];
-    for (const idx of contractTable.indexes) {
-      const key = idx.columns.join(',');
-      if (seenIndexColumnKeys.has(key)) continue;
-      seenIndexColumnKeys.add(key);
-      indexes.push({
-        name: idx.name ?? defaultIndexName(tableName, idx.columns),
-        columns: idx.columns,
-      });
-    }
-    for (const fk of contractTable.foreignKeys) {
-      if (fk.index === false) continue;
-      const key = fk.source.columns.join(',');
-      if (seenIndexColumnKeys.has(key)) continue;
-      seenIndexColumnKeys.add(key);
-      indexes.push({
-        name: defaultIndexName(tableName, fk.source.columns),
-        columns: fk.source.columns,
-      });
-    }
+    // Indexes (declared + FK-backing) are already merged and deduped by
+    // column-set at derivation (`contractToSchemaIR`'s `convertTable`).
+    const indexes: SqliteIndexSpec[] = expectedTable.indexes.map((idx) => ({
+      name: idx.name ?? defaultIndexName(tableName, idx.columns),
+      columns: idx.columns,
+    }));
 
     calls.push(
       new RecreateTableCall({
         tableName,
         contractTable: tableSpec,
-        schemaColumnNames: Object.keys(schemaTable.columns),
+        schemaColumnNames: Object.keys(actualTable.columns),
         indexes,
         summary: buildRecreateSummary(tableName, entry.issues),
         postchecks: buildRecreatePostchecks(tableName, entry.issues, tableSpec),
@@ -213,7 +180,7 @@ export const recreateTableStrategy: CallMigrationStrategy = (issues, ctx) => {
 // ============================================================================
 
 /**
- * When the policy allows `'data'` and the contract tightens one or more
+ * When the policy allows `'data'` and the expected tree tightens one or more
  * columns from nullable to NOT NULL, emit a `DataTransformCall` stub per
  * tightened column. The user fills the backfill `UPDATE` in the rendered
  * `migration.ts` before the subsequent `RecreateTableCall` copies data into
@@ -239,23 +206,38 @@ export const nullabilityTighteningBackfillStrategy: CallMigrationStrategy = (iss
 
   const calls: SqliteOpFactoryCall[] = [];
   for (const issue of issues) {
-    if (issue.kind !== 'nullability_mismatch') continue;
-    if (!issue.table || !issue.column) continue;
-    // Tightening only: `expected === 'true'` means the contract wants the
-    // column nullable (relaxing from NOT NULL → nullable), which is safe and
-    // needs no backfill.
-    if (issue.expected === 'true') continue;
+    if (
+      issueOutcome(issue) !== 'not-equal' ||
+      issue.expected === undefined ||
+      issue.actual === undefined
+    ) {
+      continue;
+    }
+    const expected = blindCast<
+      { readonly nodeKind: string },
+      'every diff-tree node declares nodeKind'
+    >(issue.expected).nodeKind;
+    if (expected !== RelationalSchemaNodeKind.column) continue;
 
-    const namespaceId = resolveNamespaceIdForIssue(issue);
-    const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-    if (!column || column.nullable === true) continue;
+    const expectedColumn = blindCast<
+      SqlColumnIR,
+      'a not-equal column issue carries the expected node'
+    >(issue.expected);
+    const actualColumn = blindCast<SqlColumnIR, 'a not-equal column issue carries the actual node'>(
+      issue.actual,
+    );
+    if (expectedColumn.nullable === actualColumn.nullable) continue; // not a nullability change
+    if (expectedColumn.nullable) continue; // relaxing — no backfill needed
+
+    const tableName = issue.path[1];
+    if (tableName === undefined) continue;
 
     calls.push(
       new DataTransformCall(
-        `data_migration.backfill-${issue.table}-${issue.column}`,
-        `Backfill NULLs in "${issue.table}"."${issue.column}" before NOT NULL tightening`,
-        issue.table,
-        issue.column,
+        `data_migration.backfill-${tableName}-${expectedColumn.name}`,
+        `Backfill NULLs in "${tableName}"."${expectedColumn.name}" before NOT NULL tightening`,
+        tableName,
+        expectedColumn.name,
       ),
     );
   }