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

package/src/core/migrations/planner.ts

@@ -11,16 +11,18 @@ 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,
+  SchemaDiffIssue,
+  SchemaOwnership,
 } from '@prisma-next/framework-components/control';
-import { parseSqliteDefault } from '../default-normalizer';
-import { normalizeSqliteNativeType } from '../native-type-normalizer';
-import { planIssues } from './issue-planner';
+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';
+import { coalesceSubtreeIssues, issueNode, planIssues } from './issue-planner';
 import {
   type SqliteMigrationDestinationInfo,
   TypeScriptRenderableSqliteMigration,
@@ -41,16 +43,18 @@ export type SqlitePlanResult =
 /**
  * SQLite migration planner — a thin wrapper over `planIssues`.
  *
- * `plan()` verifies the live schema against the target contract (producing
- * `SchemaIssue[]`) and delegates to `planIssues` with the registered
- * strategies. Strategies absorb groups of related issues into composite
- * recipes (e.g. recreating a table to apply type/nullability/default/
- * constraint changes at once); anything not absorbed by a strategy flows
- * through `mapIssueToCall` in the issue planner as a one-off call.
+ * `plan()` diffs the live schema against the target contract via the one
+ * differ (`buildSqlitePlanDiff`, producing node-typed `SchemaDiffIssue[]`)
+ * and delegates to `planIssues` with the registered strategies. Strategies
+ * absorb groups of related issues into composite recipes (e.g. recreating a
+ * table to apply type/nullability/default/constraint changes at once);
+ * anything not absorbed by a strategy flows through `mapNodeIssueToCall` in
+ * the issue planner as a one-off call.
  *
- * FK-backing indexes are surfaced by `verifySqlSchema`'s index expansion
- * (see `verify-sql-schema.ts:459-469`), so `mapIssueToCall` handles them
- * uniformly alongside user-declared indexes.
+ * FK-backing indexes are already merged into the expected table node's
+ * `indexes` at derivation (`contractToSchemaIR`'s `convertTable`), so
+ * `mapNodeIssueToCall` handles them uniformly alongside user-declared
+ * indexes — no separate expansion step in the planner.
  */
 export class SqliteMigrationPlanner
   implements SqlMigrationPlanner<SqlitePlanTargetDetails>, MigrationPlanner<'sql', 'sqlite'>
@@ -83,6 +87,11 @@ export class SqliteMigrationPlanner
      * the marker row by the right space.
      */
     readonly spaceId: string;
+    /**
+     * Ownership oracle over the contract-space composition — see
+     * {@link SqlMigrationPlannerPlanOptions.ownership}.
+     */
+    readonly ownership?: SchemaOwnership;
   }): SqlitePlanResult {
     return this.planSql(options as SqlMigrationPlannerPlanOptions);
   }
@@ -107,17 +116,13 @@ export class SqliteMigrationPlanner
     const policyResult = this.ensureAdditivePolicy(options.policy);
     if (policyResult) return policyResult;
 
-    const schemaIssues = this.collectSchemaIssues(options);
+    const { expected, actual, issues } = this.collectSchemaIssues(options);
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
-    const storageTypes = options.contract.storage.types ?? {};
 
     const result = planIssues({
-      issues: schemaIssues,
-      toContract: options.contract,
-      fromContract: options.fromContract,
-      codecHooks,
-      storageTypes,
-      schema: options.schema,
+      issues,
+      expected,
+      actual,
       policy: options.policy,
       frameworkComponents: options.frameworkComponents,
       strategies: sqlitePlannerStrategies,
@@ -178,18 +183,101 @@ export class SqliteMigrationPlanner
     return null;
   }
 
-  private collectSchemaIssues(options: SqlMigrationPlannerPlanOptions): readonly SchemaIssue[] {
+  /**
+   * Diffs the target contract against the live schema via the one differ
+   * (the same tree-building `diffSqliteSchema` uses, plus the
+   * op-render stamper) and prepares the issue list `planIssues` consumes.
+   *
+   * Three passes, in order:
+   * 1. Subtree coalescing — the differ is total (a missing/extra table also
+   *    emits an issue for every column/constraint under it); those nested
+   *    issues are redundant once the table-level `CreateTable`/`DropTable`
+   *    call already accounts for the whole subtree. Runs FIRST, over the
+   *    complete diff: a sibling-owned extra table's column issues must
+   *    collapse into its one table-level issue before the ownership pass,
+   *    because a bare column node carries no table reference — if coalescing
+   *    ran after ownership dropped the table-level issue, the orphaned column
+   *    issues would survive and the planner would emit drops against a
+   *    sibling space's table.
+   * 2. Ownership — a live extra is only this plan's to drop when no contract
+   *    space owns it. The differ ran against THIS space's contract, so a
+   *    table a sibling owns surfaces here as `not-expected`; the planner asks
+   *    the ownership oracle (the passive aggregate) whether any space declares
+   *    it and, if so, leaves it alone. A table no space owns stays a genuine
+   *    extra. Ownership lives in the aggregate; the planner only asks. No
+   *    oracle (single-space) keeps every extra.
+   * 3. Strict-mode extras gating — `not-expected` (extra table/column/
+   *    constraint) issues are dropped entirely outside strict mode, mirroring
+   *    the retired coordinate walk's `if (strict) { ...extra_* } }` guards:
+   *    an additive-only plan must never even consider dropping an unclaimed
+   *    object, not just refuse to emit the drop.
+   */
+  private collectSchemaIssues(options: SqlMigrationPlannerPlanOptions): {
+    readonly expected: SqlSchemaIR;
+    readonly actual: SqlSchemaIR;
+    readonly issues: readonly SchemaDiffIssue[];
+  } {
     const allowed = options.policy.allowedOperationClasses;
     const strict = allowed.includes('widening') || allowed.includes('destructive');
-    const verifyResult = verifySqlSchema({
+    const {
+      expected,
+      actual,
+      issues: rawIssues,
+    } = buildSqlitePlanDiff({
       contract: options.contract,
-      schema: options.schema,
-      strict,
-      typeMetadataRegistry: new Map(),
+      actualSchema: options.schema,
       frameworkComponents: options.frameworkComponents,
-      normalizeDefault: parseSqliteDefault,
-      normalizeNativeType: normalizeSqliteNativeType,
     });
-    return verifyResult.schema.issues;
+    const coalesced = coalesceSubtreeIssues(rawIssues);
+    const owned = retainUnownedExtras(coalesced, options.ownership);
+    const issues = strict ? owned : owned.filter((issue) => issueOutcome(issue) !== 'not-expected');
+    return { expected, actual, issues };
   }
 }
+
+/**
+ * Drops a `not-expected` issue when it is a whole extra TABLE that some
+ * contract space owns, asking the ownership oracle per node.
+ *
+ * The consultation applies ONLY to table-level extras — a live table this
+ * space's contract lacks — identified by asking the issue's own node
+ * (`nodeKind === table`), never by counting path segments. SQLite is a
+ * single-namespace target, so every coordinate is qualified with the shared
+ * `UNBOUND_NAMESPACE_ID` sentinel (the same one the aggregate's declared
+ * entities carry for this target). `entityKind` is the literal `'table'`:
+ * this function only ever asks about a node already confirmed to be
+ * `RelationalSchemaNodeKind.table` (checked just above), and that's a
+ * diff-tree `nodeKind` spelling (`'sql-table'`) distinct from the storage
+ * `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal
+ * is that storage-entries spelling. `declaresEntity` answers over the whole
+ * composition (self included), so a positive answer on such a table means
+ * another space owns it (a table this space owned would be in its expected
+ * tree, never an extra): leave it. A negative answer means no space owns
+ * it — a genuine orphan to drop.
+ *
+ * A DEEPER extra (an extra column/constraint on a table this space DOES own —
+ * only the child drifted, so the table is in the expected tree) is this
+ * space's own drift and is always kept for dropping; asking the oracle there
+ * would wrongly suppress it, because the owned table answers `true`. No oracle
+ * ⇒ every extra is kept (single-space plan).
+ */
+function retainUnownedExtras(
+  issues: readonly SchemaDiffIssue[],
+  ownership: SchemaOwnership | undefined,
+): readonly SchemaDiffIssue[] {
+  if (ownership === undefined) return issues;
+  return issues.filter((issue) => {
+    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];
+    return (
+      tableName === undefined ||
+      !ownership.declaresEntity({
+        namespaceId: UNBOUND_NAMESPACE_ID,
+        entityKind: 'table',
+        entityName: tableName,
+      })
+    );
+  });
+}

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,18 +38,38 @@ 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;
 
   /**
    * 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); the operation methods
-   * throw in that case to surface the misuse.
+   * was instantiated without a stack (test fixtures); `controlAdapterFor`
+   * throws a PN-MIG-2008 in that case to surface the misuse.
    */
   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,42 +80,63 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
       : undefined;
   }
 
+  /**
+   * Returns the materialized control adapter, or throws a PN-MIG-2008 naming
+   * `operation` when the migration was constructed without a `ControlStack`.
+   * Single home for the null-check that every DDL/DML method shares.
+   */
+  private controlAdapterFor(operation: string): SqlControlAdapter<'sqlite'> {
+    if (!this.controlAdapter) {
+      throw errorSqliteMigrationStackMissing(operation);
+    }
+    return this.controlAdapter;
+  }
+
+  /**
+   * 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;
     readonly columns: readonly DdlColumn[];
     readonly constraints?: readonly DdlTableConstraint[];
   }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
     return new CreateTableCall(options.table, options.columns, options.constraints).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('createTable'),
     );
   }
 
   protected dropTable(options: { readonly table: string }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
-    return new DropTableCall(options.table).toOp(this.controlAdapter);
+    return new DropTableCall(options.table).toOp(this.controlAdapterFor('dropTable'));
   }
 
   protected addColumn(options: {
     readonly table: string;
     readonly column: SqliteColumnSpec;
   }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
-    return new AddColumnCall(options.table, options.column).toOp(this.controlAdapter);
+    return new AddColumnCall(options.table, options.column).toOp(
+      this.controlAdapterFor('addColumn'),
+    );
   }
 
   protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
-    return new DropColumnCall(options.table, options.column).toOp(this.controlAdapter);
+    return new DropColumnCall(options.table, options.column).toOp(
+      this.controlAdapterFor('dropColumn'),
+    );
   }
 
   protected createIndex(options: {
@@ -99,19 +144,15 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
     readonly index: string;
     readonly columns: readonly string[];
   }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
     return new CreateIndexCall(options.table, options.index, options.columns).toOp(
-      this.controlAdapter,
+      this.controlAdapterFor('createIndex'),
     );
   }
 
   protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
-    return new DropIndexCall(options.table, options.index).toOp(this.controlAdapter);
+    return new DropIndexCall(options.table, options.index).toOp(
+      this.controlAdapterFor('dropIndex'),
+    );
   }
 
   protected recreateTable(options: {
@@ -123,9 +164,6 @@ export abstract class SqliteMigration extends SqlMigration<SqlitePlanTargetDetai
     readonly postchecks: readonly { readonly description: string; readonly sql: string }[];
     readonly operationClass: MigrationOperationClass;
   }): Promise<Op> {
-    if (!this.controlAdapter) {
-      throw errorSqliteMigrationStackMissing();
-    }
-    return new RecreateTableCall(options).toOp(this.controlAdapter);
+    return new RecreateTableCall(options).toOp(this.controlAdapterFor('recreateTable'));
   }
 }

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,36 @@ 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: this.serializeNamespaceEntries(ns.entries),
+      };
+    }
+    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: this.serializeJsonObject(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);
+  },
+};

package/src/core/sqlite-schema-verifier.ts

@@ -1,6 +1,9 @@
 import type { Contract } from '@prisma-next/contract/types';
 import { SqlSchemaVerifierBase } from '@prisma-next/family-sql/ir';
-import type { SchemaIssue, SchemaVerifyOptions } from '@prisma-next/framework-components/control';
+import type {
+  SchemaDiffIssue,
+  SchemaVerifyOptions,
+} from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 
@@ -12,13 +15,13 @@ import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 export class SqliteSchemaVerifier extends SqlSchemaVerifierBase<Contract<SqlStorage>, SqlSchemaIR> {
   protected verifyCommonSqlSchema(
     _options: SchemaVerifyOptions<Contract<SqlStorage>, SqlSchemaIR>,
-  ): readonly SchemaIssue[] {
+  ): readonly SchemaDiffIssue[] {
     return [];
   }
 
   protected verifyTargetExtensions(
     _options: SchemaVerifyOptions<Contract<SqlStorage>, SqlSchemaIR>,
-  ): readonly SchemaIssue[] {
+  ): readonly SchemaDiffIssue[] {
     return [];
   }
 }