@prisma-next/target-sqlite 0.14.0-dev.4 → 0.14.0-dev.41

package/dist/{sqlite-migration-DVfhQwN_.d.mts → sqlite-migration-_BhTcnIe.d.mts}

@@ -1,9 +1,12 @@
 import { t as SqlitePlanTargetDetails } from "./planner-target-details-xR6UfIcz.mjs";
-import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-Dhc8mLK1.mjs";
+import { i as SqliteTableSpec, n as SqliteColumnSpec, r as SqliteIndexSpec } from "./shared-C6sM-wel.mjs";
+import { t as SqliteContractView } from "./sqlite-contract-view-J32K82Gi.mjs";
 import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { MigrationOperationClass, SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
-import { Migration } from "@prisma-next/family-sql/migration";
 import { ControlStack } from "@prisma-next/framework-components/control";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { Contract } from "@prisma-next/contract/types";
 import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
 
 //#region src/core/migrations/sqlite-migration.d.ts
@@ -20,8 +23,17 @@ type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
  * forward to the corresponding `*Call` with that stored adapter, so user
  * migrations can write `this.createTable({...})` without threading the adapter
  * 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>`
+ * (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
+ * `describe()` from the same JSON.
  */
-declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails, 'sqlite'> {
+declare abstract class SqliteMigration<Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<SqlitePlanTargetDetails, 'sqlite', Start, End> {
+  #private;
   readonly targetId: "sqlite";
   /**
    * Materialized SQLite control adapter, created once per migration
@@ -31,6 +43,17 @@ declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails
    */
   protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
   constructor(stack?: ControlStack<'sql', 'sqlite'>);
+  /**
+   * The typed SQLite view over this migration's end-state contract — sole
+   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.
+   * Throws if no `endContractJson` was provided.
+   */
+  get endContract(): SqliteContractView<End>;
+  /**
+   * The typed SQLite view over this migration's start-state contract, or
+   * `null` for a baseline migration (no `startContractJson`).
+   */
+  get startContract(): SqliteContractView<Start> | null;
   protected createTable(options: {
     readonly table: string;
     readonly ifNotExists?: boolean;
@@ -72,4 +95,4 @@ declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails
 }
 //#endregion
 export { SqliteMigration as t };
-//# sourceMappingURL=sqlite-migration-DVfhQwN_.d.mts.map
+//# sourceMappingURL=sqlite-migration-_BhTcnIe.d.mts.map

package/dist/sqlite-migration-_BhTcnIe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-migration-_BhTcnIe.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;;;;;;;KA0BK,EAAA,GAAK,yBAAyB,CAAC,uBAAA;;AAFoC;;;;AAEb;AAuB3D;;;;;;;;;;;;;;;uBAAsB,eAAA,eACN,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,eAClC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,WACpC,SAAA,CAAa,uBAAA,YAAmC,KAAA,EAAO,GAAA;EAAA;WACtD,QAAA;EA0C+B;;;;;;EAAA,mBAlCrB,cAAA,EAAgB,iBAAA;cAWvB,KAAA,GAAQ,YAAA;EAkDD;;;;;EAAA,IAnCf,WAAA,IAAe,kBAAA,CAAmB,GAAA;EAsDlC;;;;EAAA,IA9CA,aAAA,IAAiB,kBAAA,CAAmB,KAAA;EAAA,UAI9B,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA,IAC9B,OAAA,CAAQ,EAAA;EAAA,UASF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAOxD,SAAA,CAAU,OAAA;IAAA,SACT,KAAA;IAAA,SACA,MAAA,EAAQ,gBAAA;EAAA,IACf,OAAA,CAAQ,EAAA;EAAA,UAOF,UAAA,CAAW,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,MAAA;EAAA,IAAmB,OAAA,CAAQ,EAAA;EAAA,UAOlF,WAAA,CAAY,OAAA;IAAA,SACX,KAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA,IACP,OAAA,CAAQ,EAAA;EAAA,UASF,SAAA,CAAU,OAAA;IAAA,SAAoB,KAAA;IAAA,SAAwB,KAAA;EAAA,IAAkB,OAAA,CAAQ,EAAA;EAAA,UAOhF,aAAA,CAAc,OAAA;IAAA,SACb,SAAA;IAAA,SACA,aAAA,EAAe,eAAA;IAAA,SACf,iBAAA;IAAA,SACA,OAAA,WAAkB,eAAA;IAAA,SAClB,OAAA;IAAA,SACA,UAAA;MAAA,SAAgC,WAAA;MAAA,SAA8B,GAAA;IAAA;IAAA,SAC9D,cAAA,EAAgB,uBAAA;EAAA,IACvB,OAAA,CAAQ,EAAA;AAAA"}

package/package.json

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

package/src/core/control-target.ts

@@ -1,16 +1,19 @@
-import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import type { Contract } from '@prisma-next/contract/types';
 import type { SqlControlTargetDescriptor } from '@prisma-next/family-sql/control';
-import { contractToSchemaIR } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import type {
   ControlTargetInstance,
   MigrationPlanner,
   MigrationRunner,
 } from '@prisma-next/framework-components/control';
-import { SqlStorage, type StorageColumn } from '@prisma-next/sql-contract/types';
+import { SqlStorage } from '@prisma-next/sql-contract/types';
 import { sqliteTargetDescriptorMeta } from './descriptor-meta';
+import {
+  diffSqliteDatabaseSchema,
+  sqliteContractToSchema,
+  verifySqliteDatabaseSchema,
+} from './migrations/diff-database-schema';
 import { createSqliteMigrationPlanner } from './migrations/planner';
-import { renderDefaultLiteral } from './migrations/planner-ddl-builders';
 import type { SqlitePlanTargetDetails } from './migrations/planner-target-details';
 import { createSqliteMigrationRunner } from './migrations/runner';
 import { SqliteContractSerializer } from './sqlite-contract-serializer';
@@ -20,21 +23,29 @@ function isSqlContract(contract: Contract | null): contract is Contract<SqlStora
   return contract === null || contract.storage instanceof SqlStorage;
 }
 
-function sqliteRenderDefault(def: ColumnDefault, _column: StorageColumn): string {
-  if (def.kind === 'function') {
-    if (def.expression === 'now()') {
-      return "datetime('now')";
-    }
-    return def.expression;
-  }
-  return renderDefaultLiteral(def.value);
-}
-
 const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', SqlitePlanTargetDetails> =
   {
     ...sqliteTargetDescriptorMeta,
     contractSerializer: new SqliteContractSerializer(),
     schemaVerifier: new SqliteSchemaVerifier(),
+    diffDatabaseSchema(input) {
+      return diffSqliteDatabaseSchema({
+        contract: input.contract,
+        actualSchema: input.schema,
+        strict: input.strict,
+        typeMetadataRegistry: input.typeMetadataRegistry,
+        frameworkComponents: input.frameworkComponents,
+      });
+    },
+    verifyDatabaseSchema(input) {
+      return verifySqliteDatabaseSchema({
+        contract: input.contract,
+        actualSchema: input.schema,
+        strict: input.strict,
+        typeMetadataRegistry: input.typeMetadataRegistry,
+        frameworkComponents: input.frameworkComponents,
+      });
+    },
     migrations: {
       createPlanner(adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
         return createSqliteMigrationPlanner(adapter);
@@ -55,10 +66,7 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
             'sqliteControlTargetDescriptor.contractToSchema received a non-SQL contract; expected Contract<SqlStorage>',
           );
         }
-        return contractToSchemaIR(contract, {
-          annotationNamespace: 'sqlite',
-          renderDefault: sqliteRenderDefault,
-        });
+        return sqliteContractToSchema(contract);
       },
     },
     create(): ControlTargetInstance<'sql', 'sqlite'> {

package/src/core/migrations/diff-database-schema.ts

@@ -0,0 +1,74 @@
+import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import { contractToSchemaIR } from '@prisma-next/family-sql/control';
+import { verifySqlSchemaTree } from '@prisma-next/family-sql/diff';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type { VerifyDatabaseSchemaResult } from '@prisma-next/framework-components/control';
+import { SchemaDiff } from '@prisma-next/framework-components/control';
+import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
+import type { SqlSchemaIR, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { parseSqliteDefault } from '../default-normalizer';
+import { normalizeSqliteNativeType } from '../native-type-normalizer';
+import { renderDefaultLiteral } from './planner-ddl-builders';
+
+interface SqliteDiffDatabaseSchemaInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly typeMetadataRegistry: ReadonlyMap<string, { readonly nativeType?: string }>;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}
+
+/** Renders a column default for the SQLite dialect. */
+export function sqliteRenderDefault(def: ColumnDefault, _column: StorageColumn): string {
+  if (def.kind === 'function') {
+    if (def.expression === 'now()') {
+      return "datetime('now')";
+    }
+    return def.expression;
+  }
+  return renderDefaultLiteral(def.value);
+}
+
+/** The SQLite expected-side projection: contract → flat relational schema IR. */
+export function sqliteContractToSchema(contract: Contract<SqlStorage> | null): SqlSchemaIR {
+  return contractToSchemaIR(contract, {
+    annotationNamespace: 'sqlite',
+    renderDefault: sqliteRenderDefault,
+  });
+}
+
+function computeSqliteSchemaComparison(
+  input: SqliteDiffDatabaseSchemaInput,
+): VerifyDatabaseSchemaResult {
+  return verifySqlSchemaTree({
+    contract: input.contract,
+    actualSchema: input.actualSchema,
+    buildExpectedSchema: sqliteContractToSchema,
+    strict: input.strict,
+    typeMetadataRegistry: input.typeMetadataRegistry,
+    frameworkComponents: input.frameworkComponents,
+    normalizeDefault: parseSqliteDefault,
+    normalizeNativeType: normalizeSqliteNativeType,
+  });
+}
+
+/**
+ * The SQLite `SchemaDiffer` — relational only. SQLite has a single flat
+ * schema and no structural (policy) diff, so it runs the shared per-schema
+ * relational diff and returns no `schemaDiffIssues`.
+ */
+export function diffSqliteDatabaseSchema(input: SqliteDiffDatabaseSchemaInput): SchemaDiff {
+  const relational = computeSqliteSchemaComparison(input);
+  return new SchemaDiff(relational.schema.issues, relational.schema.schemaDiffIssues);
+}
+
+/**
+ * The same comparison as {@link diffSqliteDatabaseSchema}, wrapped in the
+ * verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the
+ * pass/warn/fail tree the CLI renders.
+ */
+export function verifySqliteDatabaseSchema(
+  input: SqliteDiffDatabaseSchemaInput,
+): VerifyDatabaseSchemaResult {
+  return computeSqliteSchemaComparison(input);
+}

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/planner.ts

@@ -11,15 +11,15 @@ import {
   plannerFailure,
 } from '@prisma-next/family-sql/control';
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
-import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   MigrationPlanner,
   MigrationScaffoldContext,
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
-import { parseSqliteDefault } from '../default-normalizer';
-import { normalizeSqliteNativeType } from '../native-type-normalizer';
+import type { SqlSchemaIR, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { diffSqliteDatabaseSchema } from './diff-database-schema';
 import { planIssues } from './issue-planner';
 import {
   type SqliteMigrationDestinationInfo,
@@ -117,7 +117,7 @@ export class SqliteMigrationPlanner
       fromContract: options.fromContract,
       codecHooks,
       storageTypes,
-      schema: options.schema,
+      schema: sqliteFlatSchema(options.schema),
       policy: options.policy,
       frameworkComponents: options.frameworkComponents,
       strategies: sqlitePlannerStrategies,
@@ -181,15 +181,27 @@ export class SqliteMigrationPlanner
   private collectSchemaIssues(options: SqlMigrationPlannerPlanOptions): readonly SchemaIssue[] {
     const allowed = options.policy.allowedOperationClasses;
     const strict = allowed.includes('widening') || allowed.includes('destructive');
-    const verifyResult = verifySqlSchema({
+    const rawDiff = diffSqliteDatabaseSchema({
       contract: options.contract,
-      schema: options.schema,
+      actualSchema: options.schema,
       strict,
       typeMetadataRegistry: new Map(),
       frameworkComponents: options.frameworkComponents,
-      normalizeDefault: parseSqliteDefault,
-      normalizeNativeType: normalizeSqliteNativeType,
     });
-    return verifyResult.schema.issues;
+    // The caller-supplied predicate is applied blindly — any scoping (e.g.
+    // multi-space ownership) is the orchestration's, never worked out here.
+    const diff = options.keepDiffIssue ? rawDiff.filter(options.keepDiffIssue) : rawDiff;
+    return diff.issues;
   }
 }
+
+/**
+ * SQLite has a single, flat schema — its introspected node IS a per-schema
+ * `SqlSchemaIR`, never the multi-namespace tree the Postgres target builds. The
+ * planner consumes that flat shape directly when building ops.
+ */
+function sqliteFlatSchema(schema: SqlSchemaIRNode): SqlSchemaIR {
+  return blindCast<SqlSchemaIR, 'the SQLite introspected node is a flat per-schema SqlSchemaIR'>(
+    schema,
+  );
+}

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

@@ -35,15 +35,19 @@ export function renderCallsToTypeScript(
   calls: ReadonlyArray<OpFactoryCall>,
   meta: RenderMigrationMeta,
 ): string {
-  const imports = buildImports(calls);
+  const imports = buildImports(calls, meta);
   const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\n');
+  const hasStart = meta.from !== null;
+  const startField = hasStart ? ['  override readonly startContractJson = startContract;'] : [];
 
   return [
     shebangLineFor(detectScaffoldRuntime()),
     imports,
     '',
-    'export default class M extends Migration {',
-    buildDescribeMethod(meta),
+    `export default class M extends Migration<${hasStart ? 'Start' : 'never'}, End> {`,
+    ...startField,
+    '  override readonly endContractJson = endContract;',
+    '',
     '  override get operations() {',
     '    return [',
     indent(operationsBody, 6),
@@ -56,8 +60,8 @@ export function renderCallsToTypeScript(
   ].join('\n');
 }
 
-function buildImports(calls: ReadonlyArray<OpFactoryCall>): string {
-  const requirements: ImportRequirement[] = [...BASE_IMPORTS];
+function buildImports(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigrationMeta): string {
+  const requirements: ImportRequirement[] = [...BASE_IMPORTS, ...contractImports(meta)];
   for (const call of calls) {
     for (const req of call.importRequirements()) {
       requirements.push(req);
@@ -66,16 +70,39 @@ function buildImports(calls: ReadonlyArray<OpFactoryCall>): string {
   return renderImports(requirements);
 }
 
-function buildDescribeMethod(meta: RenderMigrationMeta): string {
-  const lines: string[] = [];
-  lines.push('  override describe() {');
-  lines.push('    return {');
-  lines.push(`      from: ${JSON.stringify(meta.from)},`);
-  lines.push(`      to: ${JSON.stringify(meta.to)},`);
-  lines.push('    };');
-  lines.push('  }');
-  lines.push('');
-  return lines.join('\n');
+/**
+ * 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
+ * `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',
+      symbol: 'endContract',
+      kind: 'default',
+      attributes: { type: 'json' },
+    },
+    { moduleSpecifier: './end-contract', symbol: 'Contract', alias: 'End', typeOnly: true },
+  ];
+  if (meta.from !== null) {
+    reqs.push({
+      moduleSpecifier: './start-contract.json',
+      symbol: 'startContract',
+      kind: 'default',
+      attributes: { type: 'json' },
+    });
+    reqs.push({
+      moduleSpecifier: './start-contract',
+      symbol: 'Contract',
+      alias: 'Start',
+      typeOnly: true,
+    });
+  }
+  return reqs;
 }
 
 function indent(text: string, spaces: number): string {

package/src/core/migrations/runner.ts

@@ -12,7 +12,6 @@ import type {
   SqlMigrationRunnerSuccessValue,
 } from '@prisma-next/family-sql/control';
 import { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';
-import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { MigrationRunnerResult } from '@prisma-next/framework-components/control';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import type { SqlControlDriverInstance, SqlStorage } from '@prisma-next/sql-contract/types';
@@ -22,8 +21,7 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
 import { MARKER_TABLE_NAME } from '../control-tables';
-import { parseSqliteDefault } from '../default-normalizer';
-import { normalizeSqliteNativeType } from '../native-type-normalizer';
+import { verifySqliteDatabaseSchema } from './diff-database-schema';
 import type { SqlitePlanTargetDetails } from './planner-target-details';
 
 export function createSqliteMigrationRunner(
@@ -92,20 +90,16 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     }
 
     if (space === APP_SPACE_ID) {
-      const schemaIR = await this.family.introspect({
+      const schemaNode = await this.family.introspect({
         driver,
         contract: options.destinationContract,
       });
-
-      const schemaVerifyResult = verifySqlSchema({
+      const schemaVerifyResult = verifySqliteDatabaseSchema({
         contract: options.destinationContract,
-        schema: schemaIR,
+        actualSchema: schemaNode,
         strict: options.strictVerification ?? true,
-        context: options.context ?? {},
         typeMetadataRegistry: this.family.typeMetadataRegistry,
         frameworkComponents: options.frameworkComponents,
-        normalizeDefault: parseSqliteDefault,
-        normalizeNativeType: normalizeSqliteNativeType,
       });
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {

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

@@ -1,3 +1,4 @@
+import type { Contract } from '@prisma-next/contract/types';
 import type {
   MigrationOperationClass,
   SqlMigrationPlanOperation,
@@ -5,9 +6,12 @@ import type {
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
 import type { ControlStack } from '@prisma-next/framework-components/control';
+import { MigrationContractViews } from '@prisma-next/migration-tools/migration';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import { blindCast } from '@prisma-next/utils/casts';
 import { errorSqliteMigrationStackMissing } from '../errors';
+import { SqliteContractView } from '../sqlite-contract-view';
 import {
   AddColumnCall,
   CreateIndexCall,
@@ -34,8 +38,19 @@ type Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;
  * forward to the corresponding `*Call` with that stored adapter, so user
  * migrations can write `this.createTable({...})` without threading the adapter
  * 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>`
+ * (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
+ * `describe()` from the same JSON.
  */
-export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetails, 'sqlite'> {
+export abstract class SqliteMigration<
+  Start extends Contract<SqlStorage> = Contract<SqlStorage>,
+  End extends Contract<SqlStorage> = Contract<SqlStorage>,
+> extends SqlMigration<SqlitePlanTargetDetails, 'sqlite', Start, End> {
   readonly targetId = 'sqlite' as const;
 
   /**
@@ -46,6 +61,15 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
    */
   protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;
 
+  #endView = new MigrationContractViews<SqliteContractView<End>>(this, 'SqliteMigration', (json) =>
+    SqliteContractView.fromJson<End>(json),
+  );
+  #startView = new MigrationContractViews<SqliteContractView<Start>>(
+    this,
+    'SqliteMigration',
+    (json) => SqliteContractView.fromJson<Start>(json),
+  );
+
   constructor(stack?: ControlStack<'sql', 'sqlite'>) {
     super(stack);
     this.controlAdapter = stack?.adapter
@@ -56,6 +80,23 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
       : undefined;
   }
 
+  /**
+   * The typed SQLite view over this migration's end-state contract — sole
+   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.
+   * Throws if no `endContractJson` was provided.
+   */
+  get endContract(): SqliteContractView<End> {
+    return this.#endView.endContract;
+  }
+
+  /**
+   * The typed SQLite view over this migration's start-state contract, or
+   * `null` for a baseline migration (no `startContractJson`).
+   */
+  get startContract(): SqliteContractView<Start> | null {
+    return this.#startView.startContract;
+  }
+
   protected createTable(options: {
     readonly table: string;
     readonly ifNotExists?: boolean;

package/src/core/sqlite-contract-serializer.ts

@@ -1,9 +1,9 @@
 import type { Contract } from '@prisma-next/contract/types';
 import { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';
-import { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';
-import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { Namespace } from '@prisma-next/framework-components/ir';
+import type { SqlNamespaceInput, SqlStorage } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
-import { sqliteTargetDescriptorMeta } from './descriptor-meta';
+import type { JsonObject } from '@prisma-next/utils/json';
 import { buildSqliteNamespace } from './sqlite-unbound-database';
 
 /**
@@ -17,21 +17,48 @@ export class SqliteContractSerializer extends SqlContractSerializerBase<Contract
     super(new Map());
   }
 
-  protected override get defaultNamespaceId(): string {
-    return sqliteTargetDescriptorMeta.defaultNamespaceId;
-  }
-
   protected override hydrateSqlNamespaceEntry(
     nsId: string,
-    raw: Namespace | Record<string, unknown>,
-  ): Namespace | SqlNamespaceTablesInput {
-    if (raw instanceof NamespaceBase) {
-      return raw;
-    }
+    raw: Record<string, unknown>,
+  ): Namespace | SqlNamespaceInput {
     const hydrated = blindCast<
-      SqlNamespaceTablesInput,
-      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'
+      SqlNamespaceInput,
+      'raw is always plain JSON, so super.hydrateSqlNamespaceEntry returns SqlNamespaceInput'
     >(super.hydrateSqlNamespaceEntry(nsId, raw));
     return buildSqliteNamespace(hydrated);
   }
+
+  override serializeContract(contract: Contract<SqlStorage>): JsonObject {
+    const { storage, ...rest } = contract;
+    const namespacesJson: Record<string, JsonObject> = {};
+    for (const [nsId, ns] of Object.entries(storage.namespaces)) {
+      namespacesJson[nsId] = {
+        id: ns.id,
+        entries: {
+          table: blindCast<
+            JsonObject,
+            'JSON.parse(JSON.stringify(...)) strips class methods; result is a plain JsonObject'
+          >(JSON.parse(JSON.stringify(ns.entries.table ?? {}))),
+        },
+      };
+    }
+    return blindCast<
+      JsonObject,
+      'rest + storage are serialized plain values; spread preserves JSON-clean contract envelope'
+    >({
+      ...rest,
+      storage: {
+        storageHash: String(storage.storageHash),
+        namespaces: namespacesJson,
+        ...(storage.types !== undefined
+          ? {
+              types: blindCast<
+                JsonObject,
+                'JSON.parse(JSON.stringify(...)) strips class methods; result is plain JsonObject'
+              >(JSON.parse(JSON.stringify(storage.types))),
+            }
+          : {}),
+      },
+    });
+  }
 }

package/src/core/sqlite-contract-view.ts

@@ -0,0 +1,41 @@
+import type { Contract } from '@prisma-next/contract/types';
+import {
+  buildSqlSingleNamespaceView,
+  type SqlSingleNamespaceView,
+} from '@prisma-next/sql-contract/contract-view';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { SqliteContractSerializer } from './sqlite-contract-serializer';
+
+/**
+ * A SQLite contract view: the deserialized contract intersected with by-name
+ * accessors. It is substitutable for `Contract` (carries `storage`, `domain`,
+ * …) and also exposes the single default namespace unwrapped with the SQL
+ * built-in kinds promoted:
+ *
+ * ```ts
+ * const view = SqliteContractView.fromJson<Contract>(contractJson);
+ * view.table.users      // typed table leaf
+ * view.entries.policy.X // pack-contributed kind (singular key)
+ * view.storage          // the full contract is still present
+ * ```
+ *
+ * SQLite has `sql.enums: false`, so it never emits `valueSet` entries; the
+ * `valueSet` slot is therefore an empty map.
+ */
+export type SqliteContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> =
+  SqlSingleNamespaceView<TContract>;
+
+export const SqliteContractView = {
+  /** Wrap an already-deserialized SQLite contract in a view. */
+  from<TContract extends Contract<SqlStorage>>(contract: TContract): SqliteContractView<TContract> {
+    return buildSqlSingleNamespaceView(contract);
+  },
+
+  /** Deserialize a SQLite contract JSON envelope and wrap it in a view. */
+  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>(
+    json: unknown,
+  ): SqliteContractView<TContract> {
+    const contract = new SqliteContractSerializer().deserializeContract<TContract>(json);
+    return buildSqlSingleNamespaceView(contract);
+  },
+};