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

package/dist/{sqlite-migration-C9bD6XDl.mjs → sqlite-migration-CLXPhPxF.mjs}

@@ -1,4 +1,4 @@
-import { a as DropColumnCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall } from "./op-factory-call-Do03QgD9.mjs";
+import { a as DropColumnCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall } from "./op-factory-call-8pTnIHhR.mjs";
 import { t as SqliteContractView } from "./sqlite-contract-view-B8qeCczc.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { Migration } from "@prisma-next/family-sql/migration";
@@ -17,8 +17,9 @@ import { CliStructuredError } from "@prisma-next/errors/control";
 * The `operation` argument is required so every throw site names the operation
 * that actually failed; a new operation cannot inherit a misattributed message.
 *
-* Distinct from `PN-MIG-2001` (placeholder not filled) because the missing
-* input is the stack itself, not the per-operation contract.
+* Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+* because the missing input is the stack itself, not the per-operation
+* contract.
 *
 * Lives in `@prisma-next/target-sqlite/errors` rather than the shared
 * framework migration errors module because the failure is target-specific:
@@ -26,8 +27,7 @@ import { CliStructuredError } from "@prisma-next/errors/control";
 * adapter, the SQLite-target stack) only exists in this package.
 */
 function errorSqliteMigrationStackMissing(operation) {
-	return new CliStructuredError("2008", `SqliteMigration.${operation} requires a control adapter`, {
-		domain: "MIG",
+	return new CliStructuredError("MIGRATION.SQLITE_CONTROL_STACK_MISSING", `SqliteMigration.${operation} requires a control adapter`, {
 		why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,
 		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.",
 		meta: { operation }
@@ -49,8 +49,9 @@ function errorSqliteMigrationStackMissing(operation) {
 * through every call.
 *
 * Binds the framework base's `Start` / `End` contract generics so a subclass
-* that assigns its `start-contract.json` / `end-contract.json` imports gets
-* fully-typed view accessors: `this.endContract` is a `SqliteContractView<End>`
+* that assigns its snapshot-store `contract.json` imports to
+* `startContractJson` / `endContractJson` gets fully-typed view accessors:
+* `this.endContract` is a `SqliteContractView<End>`
 * (sole namespace unwrapped to the root — `this.endContract.table.<name>`),
 * built lazily from the JSON fields via the shared `MigrationContractViews`
 * helper. Mirrors `MongoMigration`'s view getters; the framework base derives
@@ -62,7 +63,7 @@ var SqliteMigration = class extends Migration {
 	* Materialized SQLite control adapter, created once per migration
 	* instance from the injected stack. `undefined` only when the migration
 	* was instantiated without a stack (test fixtures); `controlAdapterFor`
-	* throws a PN-MIG-2008 in that case to surface the misuse.
+	* throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING in that case to surface the misuse.
 	*/
 	controlAdapter;
 	#endView = new MigrationContractViews(this, "SqliteMigration", (json) => SqliteContractView.fromJson(json));
@@ -72,7 +73,7 @@ var SqliteMigration = class extends Migration {
 		this.controlAdapter = stack?.adapter ? blindCast(stack.adapter.create(stack)) : void 0;
 	}
 	/**
-	* Returns the materialized control adapter, or throws a PN-MIG-2008 naming
+	* Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming
 	* `operation` when the migration was constructed without a `ControlStack`.
 	* Single home for the null-check that every DDL/DML method shares.
 	*/
@@ -120,4 +121,4 @@ var SqliteMigration = class extends Migration {
 //#endregion
 export { SqliteMigration as t };
 
-//# sourceMappingURL=sqlite-migration-C9bD6XDl.mjs.map
+//# sourceMappingURL=sqlite-migration-CLXPhPxF.mjs.map

package/dist/sqlite-migration-CLXPhPxF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-CLXPhPxF.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/errors.ts","../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `SqliteMigration` operation that needs the materialized control adapter\n * — named by `operation` (e.g. `createTable`, `dropColumn`, `recreateTable`) —\n * was invoked, but the migration was constructed without a `ControlStack`.\n * Concrete authoring usage always goes through the migration CLI entrypoint,\n * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this\n * error means a test fixture or ad-hoc consumer instantiated `SqliteMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection only).\n *\n * The `operation` argument is required so every throw site names the operation\n * that actually failed; a new operation cannot inherit a misattributed message.\n *\n * Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)\n * because the missing input is the stack itself, not the per-operation\n * contract.\n *\n * Lives in `@prisma-next/target-sqlite/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`SqliteMigration`, the SQLite control\n * adapter, the SQLite-target stack) only exists in this package.\n */\nexport function errorSqliteMigrationStackMissing(operation: string): CliStructuredError {\n  return new CliStructuredError(\n    'MIGRATION.SQLITE_CONTROL_STACK_MISSING',\n    `SqliteMigration.${operation} requires a control adapter`,\n    {\n      why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.',\n      meta: { operation },\n    },\n  );\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationClass,\n  SqlMigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { errorSqliteMigrationStackMissing } from '../errors';\nimport { SqliteContractView } from '../sqlite-contract-view';\nimport {\n  AddColumnCall,\n  CreateIndexCall,\n  CreateTableCall,\n  DropColumnCall,\n  DropIndexCall,\n  DropTableCall,\n  RecreateTableCall,\n} from './op-factory-call';\nimport type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\n/**\n * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`\n * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the\n * SQLite literal, so both user-authored migrations and renderer-generated\n * scaffolds can extend `SqliteMigration` directly without redeclaring\n * target-local identity.\n *\n * The constructor materializes a single SQLite `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected instance methods\n * forward to the corresponding `*Call` with that stored adapter, so user\n * migrations can write `this.createTable({...})` without threading the adapter\n * through every call.\n *\n * Binds the framework base's `Start` / `End` contract generics so a subclass\n * that assigns its snapshot-store `contract.json` imports to\n * `startContractJson` / `endContractJson` gets fully-typed view accessors:\n * `this.endContract` is a `SqliteContractView<End>`\n * (sole namespace unwrapped to the root — `this.endContract.table.<name>`),\n * built lazily from the JSON fields via the shared `MigrationContractViews`\n * helper. Mirrors `MongoMigration`'s view getters; the framework base derives\n * `describe()` from the same JSON.\n */\nexport abstract class SqliteMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<SqlitePlanTargetDetails, 'sqlite', Start, End> {\n  readonly targetId = 'sqlite' as const;\n\n  /**\n   * Materialized SQLite control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;\n\n  #endView = new MigrationContractViews<SqliteContractView<End>>(this, 'SqliteMigration', (json) =>\n    SqliteContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<SqliteContractView<Start>>(\n    this,\n    'SqliteMigration',\n    (json) => SqliteContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'sqlite'>) {\n    super(stack);\n    this.controlAdapter = stack?.adapter\n      ? blindCast<\n          SqlControlAdapter<'sqlite'>,\n          'The SQLite descriptor create() returns SqlControlAdapter<sqlite>; typed as wider ControlAdapterInstance at the framework boundary'\n        >(stack.adapter.create(stack))\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'sqlite'> {\n    if (!this.controlAdapter) {\n      throw errorSqliteMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed SQLite view over this migration's end-state contract — sole\n   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.\n   * Throws if no `endContractJson` was provided.\n   */\n  get endContract(): SqliteContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed SQLite view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): SqliteContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  protected createTable(options: {\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<Op> {\n    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(\n      this.controlAdapterFor('createTable'),\n    );\n  }\n\n  protected dropTable(options: { readonly table: string }): Promise<Op> {\n    return new DropTableCall(options.table).toOp(this.controlAdapterFor('dropTable'));\n  }\n\n  protected addColumn(options: {\n    readonly table: string;\n    readonly column: SqliteColumnSpec;\n  }): Promise<Op> {\n    return new AddColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {\n    return new DropColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected createIndex(options: {\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n  }): Promise<Op> {\n    return new CreateIndexCall(options.table, options.index, options.columns).toOp(\n      this.controlAdapterFor('createIndex'),\n    );\n  }\n\n  protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {\n    return new DropIndexCall(options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected recreateTable(options: {\n    readonly tableName: string;\n    readonly contractTable: SqliteTableSpec;\n    readonly schemaColumnNames: readonly string[];\n    readonly indexes: readonly SqliteIndexSpec[];\n    readonly summary: string;\n    readonly postchecks: readonly { readonly description: string; readonly sql: string }[];\n    readonly operationClass: MigrationOperationClass;\n  }): Promise<Op> {\n    return new RecreateTableCall(options).toOp(this.controlAdapterFor('recreateTable'));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iCAAiC,WAAuC;CACtF,OAAO,IAAI,mBACT,0CACA,mBAAmB,UAAU,8BAC7B;EACE,KAAK,mBAAmB,UAAU;EAClC,KAAK;EACL,MAAM,EAAE,UAAU;CACpB,CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;ACiBA,IAAsB,kBAAtB,cAGUA,UAA4D;CACpE,WAAoB;;;;;;;CAQpB;CAEA,WAAW,IAAI,uBAAgD,MAAM,oBAAoB,SACvF,mBAAmB,SAAc,IAAI,CACvC;CACA,aAAa,IAAI,uBACf,MACA,oBACC,SAAS,mBAAmB,SAAgB,IAAI,CACnD;CAEA,YAAY,OAAuC;EACjD,MAAM,KAAK;EACX,KAAK,iBAAiB,OAAO,UACzB,UAGE,MAAM,QAAQ,OAAO,KAAK,CAAC,IAC7B,KAAA;CACN;;;;;;CAOA,kBAA0B,WAAgD;EACxE,IAAI,CAAC,KAAK,gBACR,MAAM,iCAAiC,SAAS;EAElD,OAAO,KAAK;CACd;;;;;;CAOA,IAAI,cAAuC;EACzC,OAAO,KAAKC,SAAS;CACvB;;;;;CAMA,IAAI,gBAAkD;EACpD,OAAO,KAAKC,WAAW;CACzB;CAEA,YAAsB,SAKN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,SAAS,QAAQ,WAAW,CAAC,CAAC,KAC9E,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAAkD;EACpE,OAAO,IAAI,cAAc,QAAQ,KAAK,CAAC,CAAC,KAAK,KAAK,kBAAkB,WAAW,CAAC;CAClF;CAEA,UAAoB,SAGJ;EACd,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACtD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,WAAqB,SAA2E;EAC9F,OAAO,IAAI,eAAe,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACvD,KAAK,kBAAkB,YAAY,CACrC;CACF;CAEA,YAAsB,SAIN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,OAAO,QAAQ,OAAO,CAAC,CAAC,KACxE,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAA0E;EAC5F,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,KAAK,CAAC,CAAC,KACrD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,cAAwB,SAQR;EACd,OAAO,IAAI,kBAAkB,OAAO,CAAC,CAAC,KAAK,KAAK,kBAAkB,eAAe,CAAC;CACpF;AACF"}

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.15.0",
+  "version": "0.16.0-dev.10",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.15.0",
-    "@prisma-next/contract": "0.15.0",
-    "@prisma-next/errors": "0.15.0",
-    "@prisma-next/family-sql": "0.15.0",
-    "@prisma-next/framework-components": "0.15.0",
-    "@prisma-next/migration-tools": "0.15.0",
-    "@prisma-next/sql-contract": "0.15.0",
-    "@prisma-next/sql-errors": "0.15.0",
-    "@prisma-next/sql-relational-core": "0.15.0",
-    "@prisma-next/sql-runtime": "0.15.0",
-    "@prisma-next/sql-schema-ir": "0.15.0",
-    "@prisma-next/ts-render": "0.15.0",
-    "@prisma-next/utils": "0.15.0",
+    "@prisma-next/cli": "0.16.0-dev.10",
+    "@prisma-next/contract": "0.16.0-dev.10",
+    "@prisma-next/errors": "0.16.0-dev.10",
+    "@prisma-next/family-sql": "0.16.0-dev.10",
+    "@prisma-next/framework-components": "0.16.0-dev.10",
+    "@prisma-next/migration-tools": "0.16.0-dev.10",
+    "@prisma-next/sql-contract": "0.16.0-dev.10",
+    "@prisma-next/sql-errors": "0.16.0-dev.10",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.10",
+    "@prisma-next/sql-runtime": "0.16.0-dev.10",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.10",
+    "@prisma-next/ts-render": "0.16.0-dev.10",
+    "@prisma-next/utils": "0.16.0-dev.10",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.15.0",
-    "@prisma-next/test-utils": "0.15.0",
-    "@prisma-next/tsconfig": "0.15.0",
-    "@prisma-next/tsdown": "0.15.0",
-    "tsdown": "0.22.3",
+    "@prisma-next/driver-sqlite": "0.16.0-dev.10",
+    "@prisma-next/test-utils": "0.16.0-dev.10",
+    "@prisma-next/tsconfig": "0.16.0-dev.10",
+    "@prisma-next/tsdown": "0.16.0-dev.10",
+    "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
   },

package/src/core/authoring.ts

@@ -1,9 +1,15 @@
-import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';
+import { temporalAuthoringPresets, temporalCodecPreset } from '@prisma-next/family-sql/control';
 import type { AuthoringFieldNamespace } from '@prisma-next/framework-components/authoring';
 
 export const sqliteAuthoringFieldPresets = {
-  temporal: /* @__PURE__ */ temporalAuthoringPresets({
-    codecId: 'sqlite/datetime@1',
-    nativeType: 'text',
-  }),
+  temporal: {
+    .../* @__PURE__ */ temporalAuthoringPresets({
+      codecId: 'sqlite/datetime@1',
+      nativeType: 'text',
+    }),
+    datetime: /* @__PURE__ */ temporalCodecPreset({
+      codecId: 'sqlite/datetime@1',
+      nativeType: 'text',
+    }),
+  },
 } as const satisfies AuthoringFieldNamespace;

package/src/core/errors.ts

@@ -12,8 +12,9 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  * The `operation` argument is required so every throw site names the operation
  * that actually failed; a new operation cannot inherit a misattributed message.
  *
- * Distinct from `PN-MIG-2001` (placeholder not filled) because the missing
- * input is the stack itself, not the per-operation contract.
+ * Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+ * because the missing input is the stack itself, not the per-operation
+ * contract.
  *
  * Lives in `@prisma-next/target-sqlite/errors` rather than the shared
  * framework migration errors module because the failure is target-specific:
@@ -21,10 +22,13 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  * adapter, the SQLite-target stack) only exists in this package.
  */
 export function errorSqliteMigrationStackMissing(operation: string): CliStructuredError {
-  return new CliStructuredError('2008', `SqliteMigration.${operation} requires a control adapter`, {
-    domain: 'MIG',
-    why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,
-    fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.',
-    meta: { operation },
-  });
+  return new CliStructuredError(
+    'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
+    `SqliteMigration.${operation} requires a control adapter`,
+    {
+      why: `SqliteMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its DDL node.`,
+      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a SQLite adapter to the migration constructor in test fixtures.',
+      meta: { operation },
+    },
+  );
 }

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

@@ -21,6 +21,7 @@ import type {
 } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
+import { issueOutcome, orderIssuesByDependencies } from '@prisma-next/framework-components/control';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import {
   RelationalSchemaNodeKind,
@@ -63,51 +64,6 @@ import {
 
 export type { CallMigrationStrategy, StrategyContext };
 
-// ============================================================================
-// Node-keyed issue ordering (dependency order)
-// ============================================================================
-
-/**
- * Re-keys the legacy `ISSUE_KIND_ORDER` (kind string → priority number) on
- * `(nodeKind, reason)`. Numbers are preserved from the legacy table so the
- * dependency intent stays legible; the final emission order is actually
- * fixed downstream by category bucketing (create-table → add-column →
- * create-index → recreate → drop-column → drop-index → drop-table), so this
- * only breaks ties within a single bucket.
- */
-export function nodeIssueOrder(issue: SchemaDiffIssue): number {
-  const node = issueNode(issue);
-  if (node === undefined) return 99;
-  switch (node.nodeKind) {
-    case RelationalSchemaNodeKind.foreignKey:
-      return issue.reason === 'not-expected' ? 10 : 60;
-    case RelationalSchemaNodeKind.unique:
-      return issue.reason === 'not-expected' ? 11 : 51;
-    case RelationalSchemaNodeKind.primaryKey:
-      return issue.reason === 'not-expected' ? 12 : 50;
-    case RelationalSchemaNodeKind.index:
-      return issue.reason === 'not-expected' ? 13 : 52;
-    case RelationalSchemaNodeKind.columnDefault:
-      if (issue.reason === 'not-expected') return 14;
-      return issue.reason === 'not-found' ? 42 : 43;
-    case RelationalSchemaNodeKind.column:
-      if (issue.reason === 'not-expected') return 15;
-      return issue.reason === 'not-found' ? 30 : 40;
-    case RelationalSchemaNodeKind.table:
-      return issue.reason === 'not-expected' ? 16 : 20;
-    case RelationalSchemaNodeKind.check:
-      if (issue.reason === 'not-found') return 53;
-      return issue.reason === 'not-expected' ? 54 : 55;
-    default:
-      return 99;
-  }
-}
-
-/** Deterministic tiebreak within an order bucket: the diff path itself already encodes table → child → grandchild. */
-export function nodeIssueKey(issue: SchemaDiffIssue): string {
-  return issue.path.join(' ');
-}
-
 // ============================================================================
 // Subtree coalescing — the planner's responsibility per the differ's contract
 // ============================================================================
@@ -126,7 +82,9 @@ export function coalesceSubtreeIssues(
   issues: readonly SchemaDiffIssue[],
 ): readonly SchemaDiffIssue[] {
   const collapsingPaths = issues
-    .filter((issue) => issue.reason === 'not-found' || issue.reason === 'not-expected')
+    .filter(
+      (issue) => issueOutcome(issue) === 'not-found' || issueOutcome(issue) === 'not-expected',
+    )
     .map((issue) => issue.path);
   if (collapsingPaths.length === 0) return issues;
   return issues.filter(
@@ -180,12 +138,11 @@ export function tableSpecFromNode(table: SqlTableIR): SqliteTableSpec {
     ...(u.name !== undefined ? { name: u.name } : {}),
   }));
   // Every FK node on the expected tree is constraint-bearing by construction
-  // (contractToSchemaIR filters `constraint: false` FKs out before they ever
-  // become nodes — those only ever contribute an index, never an FK node).
+  // (a persisted `foreignKeys[]` entry is a constraint; a non-constraint FK
+  // contributes only a backing index, never an FK node).
   const foreignKeys: SqliteForeignKeySpec[] = table.foreignKeys.map((fk) => ({
     columns: fk.columns,
     references: { table: fk.referencedTable, columns: fk.referencedColumns },
-    constraint: true,
     ...(fk.name !== undefined ? { name: fk.name } : {}),
     ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),
     ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),
@@ -274,14 +231,14 @@ function buildCreateTableCalls(table: SqlTableIR): SqliteOpFactoryCall[] {
 function mapTableIssue(
   issue: SchemaDiffIssue,
 ): Result<readonly SqliteOpFactoryCall[], SqlPlannerConflict> {
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     const table = blindCast<
       SqlTableIR,
       'a not-found table issue always carries the expected table node'
     >(issue.expected);
     return ok(buildCreateTableCalls(table));
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     const table = blindCast<
       SqlTableIR,
       'a not-expected table issue always carries the actual table node'
@@ -310,7 +267,7 @@ function mapColumnIssue(
       ),
     );
   }
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     const column = blindCast<
       SqlColumnIR,
       'a not-found column issue always carries the expected column node'
@@ -323,7 +280,7 @@ function mapColumnIssue(
     const inline = table !== undefined && isInlineAutoincrementPrimaryKeyNode(table, column);
     return ok([new AddColumnCall(tableName, columnSpecFromNode(column, inline))]);
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     const column = blindCast<
       SqlColumnIR,
       'a not-expected column issue always carries the actual column node'
@@ -357,7 +314,7 @@ function mapIndexIssue(
       ),
     );
   }
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     const index = blindCast<
       SqlIndexIR,
       'a not-found index issue always carries the expected index node'
@@ -365,7 +322,7 @@ function mapIndexIssue(
     const indexName = index.name ?? defaultIndexName(tableName, index.columns);
     return ok([new CreateIndexCall(tableName, indexName, index.columns)]);
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     const index = blindCast<
       SqlIndexIR,
       'a not-expected index issue always carries the actual index node'
@@ -505,13 +462,12 @@ export function planIssues(
     }
   }
 
-  const sorted = [...remaining].sort((a, b) => {
-    const kindDelta = nodeIssueOrder(a) - nodeIssueOrder(b);
-    if (kindDelta !== 0) return kindDelta;
-    const keyA = nodeIssueKey(a);
-    const keyB = nodeIssueKey(b);
-    return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
-  });
+  // Dependency-graph order: a topological sort over the issues' `dependsOn`
+  // cross-links and containment edges (edge direction from the ordering law's
+  // presence rule), path-tiebroken for determinism. `classifyCall` bucketing
+  // downstream fixes the coarse create/recreate/drop sequence; this settles
+  // the order within each bucket.
+  const sorted = orderIssuesByDependencies(remaining);
 
   const defaultCalls: SqliteOpFactoryCall[] = [];
   const conflicts: SqlPlannerConflict[] = [];

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

@@ -563,7 +563,7 @@ export class DropIndexCall extends SqliteOpFactoryCallNode {
  * any future strategy that needs a placeholder data step can construct one
  * with its own id/label.
  *
- * `toOp()` always throws `PN-MIG-2001`: the planner cannot lower a stubbed
+ * `toOp()` always throws `MIGRATION.UNFILLED_PLACEHOLDER`: the planner cannot lower a stubbed
  * transform to a runtime op — the user must edit the rendered
  * `migration.ts` and re-emit.
  */

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,7 @@
 import type { MigrationOperationClass } from '@prisma-next/family-sql/control';
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 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';
@@ -294,7 +295,7 @@ export function buildRecreatePostchecks(
 
   for (const issue of issues) {
     const nodeKind = nodeKindOf(issue);
-    if (nodeKind === RelationalSchemaNodeKind.column && issue.reason === 'not-equal') {
+    if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === 'not-equal') {
       const columnName = columnNameFromNode(issue);
       if (columnName === undefined) continue;
       const c = escapeLiteral(columnName);
@@ -325,7 +326,7 @@ export function buildRecreatePostchecks(
       const columnName = columnNameFromDefaultIssuePath(issue);
       if (columnName === undefined) continue;
       const c = escapeLiteral(columnName);
-      if (issue.reason === 'not-expected') {
+      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`,

package/src/core/migrations/planner-produced-sqlite-migration.ts

@@ -25,6 +25,7 @@ export class TypeScriptRenderableSqliteMigration
   readonly #meta: MigrationMeta;
   readonly #destination: SqliteMigrationDestinationInfo;
   readonly #spaceId: string;
+  readonly #snapshotsImportPath: string;
   readonly #lowerer: ExecuteRequestLowerer | undefined;
   #operationsCache: readonly (Op | Promise<Op>)[] | undefined;
 
@@ -32,6 +33,7 @@ export class TypeScriptRenderableSqliteMigration
     calls: readonly OpFactoryCall[],
     meta: MigrationMeta,
     spaceId: string,
+    snapshotsImportPath: string,
     destination?: SqliteMigrationDestinationInfo,
     lowerer?: ExecuteRequestLowerer,
   ) {
@@ -39,6 +41,7 @@ export class TypeScriptRenderableSqliteMigration
     this.#calls = calls;
     this.#meta = meta;
     this.#spaceId = spaceId;
+    this.#snapshotsImportPath = snapshotsImportPath;
     this.#destination = destination ?? { storageHash: meta.to };
     this.#lowerer = lowerer;
   }
@@ -69,6 +72,7 @@ export class TypeScriptRenderableSqliteMigration
     return renderCallsToTypeScript(this.#calls, {
       from: this.#meta.from,
       to: this.#meta.to,
+      snapshotsImportPath: this.#snapshotsImportPath,
     });
   }
 }

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

@@ -19,6 +19,7 @@ import type {
 } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 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 {
   RelationalSchemaNodeKind,
@@ -78,7 +79,7 @@ function classifyNodeIssue(issue: SchemaDiffIssue): 'widening' | 'destructive' |
   >(node).nodeKind;
   switch (nodeKind) {
     case RelationalSchemaNodeKind.column: {
-      if (issue.reason !== 'not-equal') return null;
+      if (issueOutcome(issue) !== 'not-equal') return null;
       const expected = blindCast<SqlColumnIR, 'a not-equal column issue carries the expected node'>(
         issue.expected,
       );
@@ -91,7 +92,7 @@ function classifyNodeIssue(issue: SchemaDiffIssue): 'widening' | 'destructive' |
       return expected.nullable ? 'widening' : 'destructive';
     }
     case RelationalSchemaNodeKind.columnDefault:
-      return issue.reason === 'not-expected' ? 'destructive' : 'widening';
+      return issueOutcome(issue) === 'not-expected' ? 'destructive' : 'widening';
     case RelationalSchemaNodeKind.primaryKey:
     case RelationalSchemaNodeKind.foreignKey:
     case RelationalSchemaNodeKind.unique:
@@ -206,7 +207,7 @@ export const nullabilityTighteningBackfillStrategy: CallMigrationStrategy = (iss
   const calls: SqliteOpFactoryCall[] = [];
   for (const issue of issues) {
     if (
-      issue.reason !== 'not-equal' ||
+      issueOutcome(issue) !== 'not-equal' ||
       issue.expected === undefined ||
       issue.actual === undefined
     ) {

package/src/core/migrations/planner.ts

@@ -18,6 +18,7 @@ import type {
   SchemaDiffIssue,
   SchemaOwnership,
 } from '@prisma-next/framework-components/control';
+import { issueOutcome } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { RelationalSchemaNodeKind, type SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { buildSqlitePlanDiff } from './diff-database-schema';
@@ -91,6 +92,12 @@ export class SqliteMigrationPlanner
      * {@link SqlMigrationPlannerPlanOptions.ownership}.
      */
     readonly ownership?: SchemaOwnership;
+    /**
+     * POSIX-relative path from the migration package dir to
+     * `migrations/snapshots` — see
+     * {@link SqlMigrationPlannerPlanOptions.snapshotsImportPath}.
+     */
+    readonly snapshotsImportPath: string;
   }): SqlitePlanResult {
     return this.planSql(options as SqlMigrationPlannerPlanOptions);
   }
@@ -106,6 +113,7 @@ export class SqliteMigrationPlanner
         to: context.toHash,
       },
       spaceId,
+      context.snapshotsImportPath,
       undefined,
       this.#lowerer,
     );
@@ -163,6 +171,7 @@ export class SqliteMigrationPlanner
           to: options.contract.storage.storageHash,
         },
         options.spaceId,
+        options.snapshotsImportPath,
         destination,
         this.#lowerer,
       ),
@@ -229,7 +238,7 @@ export class SqliteMigrationPlanner
     });
     const coalesced = coalesceSubtreeIssues(rawIssues);
     const owned = retainUnownedExtras(coalesced, options.ownership);
-    const issues = strict ? owned : owned.filter((issue) => issue.reason !== 'not-expected');
+    const issues = strict ? owned : owned.filter((issue) => issueOutcome(issue) !== 'not-expected');
     return { expected, actual, issues };
   }
 }
@@ -266,7 +275,7 @@ function retainUnownedExtras(
 ): readonly SchemaDiffIssue[] {
   if (ownership === undefined) return issues;
   return issues.filter((issue) => {
-    if (issue.reason !== 'not-expected') return true;
+    if (issueOutcome(issue) !== 'not-expected') return true;
     const node = issueNode(issue);
     if (node === undefined || node.nodeKind !== RelationalSchemaNodeKind.table) return true;
     const tableName = issue.path[1];

package/src/core/migrations/render-typescript.ts

@@ -4,13 +4,19 @@
  * specifier, same overall shape.
  */
 
-import type { OpFactoryCall } from '@prisma-next/framework-components/control';
+import {
+  contractSnapshotJsonSpecifier,
+  contractSnapshotTypesSpecifier,
+  type OpFactoryCall,
+} from '@prisma-next/framework-components/control';
 import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
 import { type ImportRequirement, renderImports } from '@prisma-next/ts-render';
 
 export interface RenderMigrationMeta {
   readonly from: string | null;
   readonly to: string;
+  /** POSIX-relative path from the migration package dir to `migrations/snapshots`, e.g. '../../snapshots'. */
+  readonly snapshotsImportPath: string;
 }
 
 /**
@@ -72,31 +78,37 @@ function buildImports(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigration
 
 /**
  * The committed contract-JSON imports the scaffold reads its from/to identity
- * from. `end-contract.json` is always present; `start-contract.json` is added
- * only for a non-baseline migration (`meta.from !== null`). The matching
- * `Contract` type imports (aliased `Start`/`End`) feed the
+ * from, resolved to the deduplicated snapshot store under
+ * `meta.snapshotsImportPath`. The end snapshot is always present; the start
+ * snapshot is added only for a non-baseline migration (`meta.from !== null`).
+ * The matching `Contract` type imports (aliased `Start`/`End`) feed the
  * `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with
  * no start imports — `never` is the honest "no prior contract" Start.
  */
 function contractImports(meta: RenderMigrationMeta): readonly ImportRequirement[] {
   const reqs: ImportRequirement[] = [
     {
-      moduleSpecifier: './end-contract.json',
+      moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),
       symbol: 'endContract',
       kind: 'default',
       attributes: { type: 'json' },
     },
-    { moduleSpecifier: './end-contract', symbol: 'Contract', alias: 'End', typeOnly: true },
+    {
+      moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),
+      symbol: 'Contract',
+      alias: 'End',
+      typeOnly: true,
+    },
   ];
   if (meta.from !== null) {
     reqs.push({
-      moduleSpecifier: './start-contract.json',
+      moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),
       symbol: 'startContract',
       kind: 'default',
       attributes: { type: 'json' },
     });
     reqs.push({
-      moduleSpecifier: './start-contract',
+      moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),
       symbol: 'Contract',
       alias: 'Start',
       typeOnly: true,