@prisma-next/target-sqlite 0.16.0-dev.3 → 0.16.0-dev.31

package/dist/{sqlite-migration-BcFf2OFa.mjs → sqlite-migration-DrZIdg3i.mjs}

@@ -1,39 +1,9 @@
-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 { t as errorSqliteMigrationStackMissing } from "./errors-B1JPoWDh.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-BkqsWGiy.mjs";
+import { t as SqliteContractView } from "./sqlite-contract-view-DthhfCpb.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { Migration } from "@prisma-next/family-sql/migration";
 import { MigrationContractViews } from "@prisma-next/migration-tools/migration";
-import { CliStructuredError } from "@prisma-next/errors/control";
-//#region src/core/errors.ts
-/**
-* A `SqliteMigration` operation that needs the materialized control adapter
-* — named by `operation` (e.g. `createTable`, `dropColumn`, `recreateTable`) —
-* was invoked, but the migration was constructed without a `ControlStack`.
-* Concrete authoring usage always goes through the migration CLI entrypoint,
-* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
-* error means a test fixture or ad-hoc consumer instantiated `SqliteMigration`
-* with the no-arg form (legal for `operations` / `describe` introspection only).
-*
-* 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 `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:
-* the contract it talks about (`SqliteMigration`, the SQLite control
-* adapter, the SQLite-target stack) only exists in this package.
-*/
-function errorSqliteMigrationStackMissing(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 }
-	});
-}
-//#endregion
 //#region src/core/migrations/sqlite-migration.ts
 /**
 * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`
@@ -49,8 +19,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
@@ -120,4 +91,4 @@ var SqliteMigration = class extends Migration {
 //#endregion
 export { SqliteMigration as t };
 
-//# sourceMappingURL=sqlite-migration-BcFf2OFa.mjs.map
+//# sourceMappingURL=sqlite-migration-DrZIdg3i.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-DrZIdg3i.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,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,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.16.0-dev.3",
+  "version": "0.16.0-dev.31",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.16.0-dev.3",
-    "@prisma-next/contract": "0.16.0-dev.3",
-    "@prisma-next/errors": "0.16.0-dev.3",
-    "@prisma-next/family-sql": "0.16.0-dev.3",
-    "@prisma-next/framework-components": "0.16.0-dev.3",
-    "@prisma-next/migration-tools": "0.16.0-dev.3",
-    "@prisma-next/sql-contract": "0.16.0-dev.3",
-    "@prisma-next/sql-errors": "0.16.0-dev.3",
-    "@prisma-next/sql-relational-core": "0.16.0-dev.3",
-    "@prisma-next/sql-runtime": "0.16.0-dev.3",
-    "@prisma-next/sql-schema-ir": "0.16.0-dev.3",
-    "@prisma-next/ts-render": "0.16.0-dev.3",
-    "@prisma-next/utils": "0.16.0-dev.3",
+    "@prisma-next/cli": "0.16.0-dev.31",
+    "@prisma-next/contract": "0.16.0-dev.31",
+    "@prisma-next/errors": "0.16.0-dev.31",
+    "@prisma-next/family-sql": "0.16.0-dev.31",
+    "@prisma-next/framework-components": "0.16.0-dev.31",
+    "@prisma-next/migration-tools": "0.16.0-dev.31",
+    "@prisma-next/sql-contract": "0.16.0-dev.31",
+    "@prisma-next/sql-errors": "0.16.0-dev.31",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.31",
+    "@prisma-next/sql-runtime": "0.16.0-dev.31",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.31",
+    "@prisma-next/ts-render": "0.16.0-dev.31",
+    "@prisma-next/utils": "0.16.0-dev.31",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.16.0-dev.3",
-    "@prisma-next/test-utils": "0.16.0-dev.3",
-    "@prisma-next/tsconfig": "0.16.0-dev.3",
-    "@prisma-next/tsdown": "0.16.0-dev.3",
+    "@prisma-next/driver-sqlite": "0.16.0-dev.31",
+    "@prisma-next/test-utils": "0.16.0-dev.31",
+    "@prisma-next/tsconfig": "0.16.0-dev.31",
+    "@prisma-next/tsdown": "0.16.0-dev.31",
     "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"

package/src/core/codecs.ts

@@ -38,6 +38,7 @@ import {
   SQLITE_REAL_CODEC_ID,
   SQLITE_TEXT_CODEC_ID,
 } from './codec-ids';
+import { sqliteError } from './errors';
 
 export class SqliteTextCodec extends CodecImpl<
   typeof SQLITE_TEXT_CODEC_ID,
@@ -170,7 +171,13 @@ export class SqliteBlobCodec extends CodecImpl<
   }
   decodeJson(json: JsonValue): Uint8Array {
     if (typeof json !== 'string') {
-      throw new TypeError('sqlite/blob@1 contract value must be a base64 string');
+      throw sqliteError(
+        'RUNTIME.DECODE_FAILED',
+        'sqlite/blob@1 contract value must be a base64 string',
+        {
+          meta: { codecId: SQLITE_BLOB_CODEC_ID, received: typeof json },
+        },
+      );
     }
     return new Uint8Array(Buffer.from(json, 'base64'));
   }
@@ -204,7 +211,11 @@ export class SqliteDatetimeCodec extends CodecImpl<
   private parseDate(value: string): Date {
     const date = new Date(value);
     if (Number.isNaN(date.getTime())) {
-      throw new TypeError(`sqlite/datetime@1 value must be a valid ISO-8601 string: ${value}`);
+      throw sqliteError(
+        'RUNTIME.DECODE_FAILED',
+        `sqlite/datetime@1 value must be a valid ISO-8601 string: ${value}`,
+        { meta: { codecId: SQLITE_DATETIME_CODEC_ID, received: value } },
+      );
     }
     return date;
   }
@@ -219,7 +230,11 @@ export class SqliteDatetimeCodec extends CodecImpl<
   }
   decodeJson(json: JsonValue): Date {
     if (typeof json !== 'string') {
-      throw new TypeError('sqlite/datetime@1 contract value must be an ISO-8601 string');
+      throw sqliteError(
+        'RUNTIME.DECODE_FAILED',
+        'sqlite/datetime@1 contract value must be an ISO-8601 string',
+        { meta: { codecId: SQLITE_DATETIME_CODEC_ID, received: typeof json } },
+      );
     }
     return this.parseDate(json);
   }
@@ -296,16 +311,28 @@ export class SqliteBigintCodec extends CodecImpl<
   encodeJson(value: bigint): JsonValue {
     const number = Number(value);
     if (!Number.isSafeInteger(number)) {
-      throw new TypeError('sqlite/bigint@1 database JSON value must be a safe integer');
+      throw sqliteError(
+        'RUNTIME.ENCODE_FAILED',
+        'sqlite/bigint@1 database JSON value must be a safe integer',
+        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: String(value) } },
+      );
     }
     return number;
   }
   decodeJson(json: JsonValue): bigint {
     if (typeof json !== 'number') {
-      throw new TypeError('sqlite/bigint@1 database JSON value must be a number');
+      throw sqliteError(
+        'RUNTIME.DECODE_FAILED',
+        'sqlite/bigint@1 database JSON value must be a number',
+        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: typeof json } },
+      );
     }
     if (!Number.isSafeInteger(json)) {
-      throw new TypeError('sqlite/bigint@1 database JSON value must be a safe integer');
+      throw sqliteError(
+        'RUNTIME.DECODE_FAILED',
+        'sqlite/bigint@1 database JSON value must be a safe integer',
+        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: json } },
+      );
     }
     return BigInt(json);
   }

package/src/core/control-target.ts

@@ -12,6 +12,7 @@ import {
   relationalNodeGranularity,
 } from '@prisma-next/sql-schema-ir/types';
 import { sqliteTargetDescriptorMeta } from './descriptor-meta';
+import { sqliteError } from './errors';
 import { diffSqliteSchema, sqliteContractToSchema } from './migrations/diff-database-schema';
 import { createSqliteMigrationPlanner } from './migrations/planner';
 import type { SqlitePlanTargetDetails } from './migrations/planner-target-details';
@@ -49,7 +50,8 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
         // encodes that invariant at runtime + narrows the generic
         // to `Contract<SqlStorage>` without a blind cast.
         if (!isSqlContract(contract)) {
-          throw new Error(
+          throw sqliteError(
+            'CONTRACT.TARGET_MISMATCH',
             'sqliteControlTargetDescriptor.contractToSchema received a non-SQL contract; expected Contract<SqlStorage>',
           );
         }

package/src/core/errors.ts

@@ -1,4 +1,28 @@
 import { CliStructuredError } from '@prisma-next/errors/control';
+import type { StructuredError, StructuredErrorOptions } from '@prisma-next/utils/structured-error';
+import { structuredError } from '@prisma-next/utils/structured-error';
+
+export type SqliteTargetErrorCode =
+  | 'CONTRACT.CONSTRAINT_INVALID'
+  | 'CONTRACT.DEFAULT_INVALID'
+  | 'CONTRACT.IDENTIFIER_INVALID'
+  | 'CONTRACT.NAMESPACE_INVALID'
+  | 'CONTRACT.NATIVE_TYPE_INVALID'
+  | 'CONTRACT.TARGET_MISMATCH'
+  | 'CONTRACT.TYPE_UNKNOWN'
+  | 'MIGRATION.CONTRACT_SPACE_VIOLATION'
+  | 'MIGRATION.SQLITE_CONTROL_STACK_MISSING'
+  | 'MIGRATION.TARGET_MISMATCH'
+  | 'RUNTIME.DECODE_FAILED'
+  | 'RUNTIME.ENCODE_FAILED';
+
+export function sqliteError(
+  code: SqliteTargetErrorCode,
+  message: string,
+  options?: StructuredErrorOptions,
+): StructuredError {
+  return structuredError(code, message, options);
+}
 
 /**
  * A `SqliteMigration` operation that needs the materialized control adapter

package/src/core/migrations/column-ddl-rendering.ts

@@ -10,6 +10,7 @@ import {
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlColumnIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
+import { assertNever, InternalError } from '@prisma-next/utils/internal-error';
 import type { SqliteColumnSpec } from './operations/shared';
 import { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';
 
@@ -28,7 +29,7 @@ function columnLike(
   column: SqlColumnIR,
 ): Pick<StorageColumn, 'nativeType' | 'codecId' | 'nullable' | 'many' | 'typeParams' | 'default'> {
   if (column.codecRef === undefined || column.codecBaseNativeType === undefined) {
-    throw new Error(
+    throw new InternalError(
       `columnLike: expected column "${column.name}" carries no codec identity — the expected tree must be derived via contractToSchemaIR for planning`,
     );
   }
@@ -69,7 +70,8 @@ function sqliteDefaultToDdlColumnDefault(
       return new FunctionColumnDefault(columnDefault.expression);
     default: {
       const exhaustive: never = columnDefault;
-      throw new Error(
+      return assertNever(
+        exhaustive,
         `sqliteDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
       );
     }

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

@@ -22,7 +22,6 @@ import type {
 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,
   type SqlColumnIR,
@@ -218,8 +217,8 @@ function buildCreateTableCalls(table: SqlTableIR): SqliteOpFactoryCall[] {
     new CreateTableCall(table.name, columns, constraints.length > 0 ? constraints : undefined),
   ];
   for (const index of table.indexes) {
-    const indexName = index.name ?? defaultIndexName(table.name, index.columns);
-    calls.push(new CreateIndexCall(table.name, indexName, index.columns));
+    const indexName = index.name;
+    calls.push(new CreateIndexCall(table.name, indexName, index.columns ?? []));
   }
   return calls;
 }
@@ -319,15 +318,15 @@ function mapIndexIssue(
       SqlIndexIR,
       'a not-found index issue always carries the expected index node'
     >(issue.expected);
-    const indexName = index.name ?? defaultIndexName(tableName, index.columns);
-    return ok([new CreateIndexCall(tableName, indexName, index.columns)]);
+    const indexName = index.name;
+    return ok([new CreateIndexCall(tableName, indexName, index.columns ?? [])]);
   }
   if (issueOutcome(issue) === 'not-expected') {
     const index = blindCast<
       SqlIndexIR,
       'a not-expected index issue always carries the actual index node'
     >(issue.actual);
-    const indexName = index.name ?? defaultIndexName(tableName, index.columns);
+    const indexName = index.name;
     return ok([new DropIndexCall(tableName, indexName)]);
   }
   // not-equal: index type/options/uniqueness drift. SQLite can't ALTER an

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

@@ -25,6 +25,7 @@ import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-ne
 import { ifDefined } from '@prisma-next/utils/defined';
 import { columnExistsAst, indexExistsAst, tableExistsAst } from '../../contract-free/checks';
 import * as contractFreeDdl from '../../contract-free/ddl';
+import { sqliteError } from '../errors';
 import { quoteIdentifier } from '../sql-utils';
 import { addColumnExecuteSql, dropColumnExecuteSql } from './operations/columns';
 import type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';
@@ -97,9 +98,11 @@ function renderDdlConstraintAsTsCall(constraint: DdlTableConstraint): string {
       return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
     }
     case 'check-expression':
-      throw new Error(
+      throw sqliteError(
+        'CONTRACT.CONSTRAINT_INVALID',
         `SQLite does not support expression CHECK constraints (constraint "${constraint.name}"). ` +
           'Scalar-array columns and their element-non-null checks are Postgres-only.',
+        { meta: { constraintName: constraint.name } },
       );
   }
 }
@@ -147,8 +150,10 @@ export class CreateTableCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `CreateTableCall.toOp: a DDL lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        { meta: { factory: this.factoryName, tableName: this.tableName } },
       );
     }
     const ddlNode = contractFreeDdl.createTable({
@@ -223,8 +228,10 @@ export class DropTableCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `DropTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        { meta: { factory: this.factoryName, tableName: this.tableName } },
       );
     }
     const checks = tableExistsAst(this.tableName);
@@ -287,8 +294,10 @@ export class RecreateTableCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `RecreateTableCall.toOp: a lowerer is required on the SQLite planner path (table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        { meta: { factory: this.factoryName, tableName: this.tableName } },
       );
     }
     return recreateTable(
@@ -346,8 +355,16 @@ export class AddColumnCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `AddColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        {
+          meta: {
+            factory: this.factoryName,
+            tableName: this.tableName,
+            columnName: this.column.name,
+          },
+        },
       );
     }
     const checks = columnExistsAst(this.tableName, this.column.name);
@@ -396,8 +413,16 @@ export class DropColumnCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `DropColumnCall.toOp: a lowerer is required on the SQLite planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        {
+          meta: {
+            factory: this.factoryName,
+            tableName: this.tableName,
+            columnName: this.columnName,
+          },
+        },
       );
     }
     const checks = columnExistsAst(this.tableName, this.columnName);
@@ -467,8 +492,12 @@ export class CreateIndexCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `CreateIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        {
+          meta: { factory: this.factoryName, tableName: this.tableName, indexName: this.indexName },
+        },
       );
     }
     const checks = indexExistsAst(this.indexName);
@@ -520,8 +549,12 @@ export class DropIndexCall extends SqliteOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw sqliteError(
+        'MIGRATION.SQLITE_CONTROL_STACK_MISSING',
         `DropIndexCall.toOp: a lowerer is required on the SQLite planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createSqliteMigrationPlanner.`,
+        {
+          meta: { factory: this.factoryName, tableName: this.tableName, indexName: this.indexName },
+        },
       );
     }
     const checks = indexExistsAst(this.indexName);

package/src/core/migrations/planner-ddl-builders.ts

@@ -13,6 +13,7 @@ import type {
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import { sqliteError } from '../errors';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 
 type SqliteColumnDefault = StorageColumn['default'];
@@ -21,18 +22,22 @@ const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*$/;
 
 function assertSafeNativeType(nativeType: string): void {
   if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {
-    throw new Error(
+    throw sqliteError(
+      'CONTRACT.NATIVE_TYPE_INVALID',
       `Unsafe native type name in contract: "${nativeType}". ` +
         'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*$/',
+      { meta: { nativeType } },
     );
   }
 }
 
 function assertSafeDefaultExpression(expression: string): void {
   if (expression.includes(';') || /--|\/\*|\bSELECT\b/i.test(expression)) {
-    throw new Error(
+    throw sqliteError(
+      'CONTRACT.DEFAULT_INVALID',
       `Unsafe default expression in contract: "${expression}". ` +
         'Default expressions must not contain semicolons, SQL comment tokens, or subqueries.',
+      { meta: { expression } },
     );
   }
 }
@@ -130,8 +135,10 @@ export function resolveColumnTypeMetadata(
   }
   const referencedType = storageTypes[column.typeRef];
   if (!referencedType) {
-    throw new Error(
+    throw sqliteError(
+      'CONTRACT.TYPE_UNKNOWN',
       `Storage type "${column.typeRef}" referenced by column is not defined in storage.types.`,
+      { meta: { typeRef: column.typeRef } },
     );
   }
   return {

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

@@ -20,7 +20,6 @@ import type {
 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,
   type SqlColumnIR,
@@ -150,8 +149,8 @@ export const recreateTableStrategy: CallMigrationStrategy = (issues, ctx) => {
     // 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,
+      name: idx.name,
+      columns: idx.columns ?? [],
     }));
 
     calls.push(

package/src/core/migrations/planner.ts

@@ -92,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);
   }
@@ -107,6 +113,7 @@ export class SqliteMigrationPlanner
         to: context.toHash,
       },
       spaceId,
+      context.snapshotsImportPath,
       undefined,
       this.#lowerer,
     );
@@ -164,6 +171,7 @@ export class SqliteMigrationPlanner
           to: options.contract.storage.storageHash,
         },
         options.spaceId,
+        options.snapshotsImportPath,
         destination,
         this.#lowerer,
       ),

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

@@ -6,6 +6,7 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { blindCast } from '@prisma-next/utils/casts';
 import { isThenable } from '@prisma-next/utils/promise';
+import { sqliteError } from '../errors';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
@@ -16,8 +17,10 @@ function assertSqliteOp(op: MigrationPlanOperation, callFactoryName: string): as
     'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'
   >(op).target?.id;
   if (targetId !== 'sqlite') {
-    throw new Error(
+    throw sqliteError(
+      'MIGRATION.TARGET_MISMATCH',
       `renderOps: expected sqlite op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the sqlite planner path; check the call's target binding.`,
+      { meta: { opId: op.id, targetId: String(targetId), factoryName: callFactoryName } },
     );
   }
 }