@prisma-next/target-sqlite 0.12.0 → 0.13.0-dev.10

package/src/core/control-target.ts

@@ -1,9 +1,7 @@
 import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
-import type {
-  SqlControlFamilyInstance,
-  SqlControlTargetDescriptor,
-} from '@prisma-next/family-sql/control';
+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,
@@ -38,7 +36,7 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
     contractSerializer: new SqliteContractSerializer(),
     schemaVerifier: new SqliteSchemaVerifier(),
     migrations: {
-      createPlanner(_family: SqlControlFamilyInstance): MigrationPlanner<'sql', 'sqlite'> {
+      createPlanner(_adapter: SqlControlAdapter<'sqlite'>): MigrationPlanner<'sql', 'sqlite'> {
         return createSqliteMigrationPlanner();
       },
       createRunner(family) {
@@ -69,7 +67,7 @@ const sqliteControlTargetDescriptor: SqlControlTargetDescriptor<'sqlite', Sqlite
         targetId: 'sqlite',
       };
     },
-    createPlanner(_family: SqlControlFamilyInstance) {
+    createPlanner(_adapter: SqlControlAdapter<'sqlite'>) {
       return createSqliteMigrationPlanner();
     },
     createRunner(family) {

package/src/core/ddl/nodes.ts

@@ -0,0 +1,54 @@
+import {
+  type DdlColumn,
+  DdlNode,
+  type DdlTableConstraint,
+} from '@prisma-next/sql-relational-core/ast';
+
+export interface SqliteDdlVisitor<R> {
+  createTable(node: SqliteCreateTable): R;
+}
+
+export abstract class SqliteDdlNode extends DdlNode {
+  abstract accept<R>(visitor: SqliteDdlVisitor<R>): R;
+}
+
+function freezeDdlColumns(columns: readonly DdlColumn[]): ReadonlyArray<DdlColumn> {
+  return Object.freeze([...columns]);
+}
+
+function freezeConstraints(
+  constraints: readonly DdlTableConstraint[] | undefined,
+): ReadonlyArray<DdlTableConstraint> | undefined {
+  return constraints ? Object.freeze([...constraints]) : undefined;
+}
+
+export class SqliteCreateTable extends SqliteDdlNode {
+  readonly kind = 'create-table' as const;
+  readonly table: string;
+  readonly schema: string | undefined;
+  readonly ifNotExists: boolean | undefined;
+  readonly columns: ReadonlyArray<DdlColumn>;
+  readonly constraints: ReadonlyArray<DdlTableConstraint> | undefined;
+
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }) {
+    super();
+    this.table = options.table;
+    this.schema = options.schema;
+    this.ifNotExists = options.ifNotExists;
+    this.columns = freezeDdlColumns(options.columns);
+    this.constraints = freezeConstraints(options.constraints);
+    this.freeze();
+  }
+
+  override accept<R>(visitor: SqliteDdlVisitor<R>): R {
+    return visitor.createTable(this);
+  }
+}
+
+export type AnySqliteDdlNode = SqliteCreateTable;

package/src/core/descriptor-meta-runtime.ts

@@ -0,0 +1,28 @@
+// Runtime-safe slice of the sqlite target descriptor metadata.
+//
+// This file exists separately from ./descriptor-meta on purpose: the runtime
+// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the
+// `__codecTypes` phantom). The `authoring` slot lives on the pack/control
+// descriptor only, because authoring contributions are consumed at
+// contract-construction time by `assembleAuthoringContributions` (control
+// plane) and the PSL interpreter — never at runtime.
+//
+// Keeping the runtime closure free of the `./authoring` import is what lets
+// the bundler tree-shake `@prisma-next/family-sql/control` (and its
+// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not
+// add an `authoring` field here — if you need to, the pack/control meta in
+// `./descriptor-meta` is the right place. See TML-2766 for context.
+import type { CodecTypes } from '../exports/codec-types';
+
+const sqliteTargetDescriptorMetaRuntimeBase = {
+  kind: 'target',
+  familyId: 'sql',
+  targetId: 'sqlite',
+  id: 'sqlite',
+  version: '0.0.1',
+  capabilities: {},
+} as const;
+
+export const sqliteTargetDescriptorMetaRuntime: typeof sqliteTargetDescriptorMetaRuntimeBase & {
+  readonly __codecTypes?: CodecTypes;
+} = sqliteTargetDescriptorMetaRuntimeBase;

package/src/core/descriptor-meta.ts

@@ -1,13 +1,11 @@
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { CodecTypes } from '../exports/codec-types';
 import { sqliteAuthoringFieldPresets } from './authoring';
+import { sqliteTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
 
 const sqliteTargetDescriptorMetaBase = {
-  kind: 'target',
-  familyId: 'sql',
-  targetId: 'sqlite',
-  id: 'sqlite',
-  version: '0.0.1',
-  capabilities: {},
+  ...sqliteTargetDescriptorMetaRuntime,
+  defaultNamespaceId: UNBOUND_NAMESPACE_ID,
   authoring: {
     field: sqliteAuthoringFieldPresets,
   },

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

@@ -28,6 +28,7 @@ import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
+import { CONTROL_TABLE_NAMES } from '../control-tables';
 import {
   AddColumnCall,
   CreateIndexCall,
@@ -55,7 +56,6 @@ import {
   sqlitePlannerStrategies,
   tableAt,
 } from './planner-strategies';
-import { CONTROL_TABLE_NAMES } from './statement-builders';
 
 export type { CallMigrationStrategy, StrategyContext };
 

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

@@ -1,4 +1,5 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
 import type { ReferentialAction } from '@prisma-next/sql-contract/types';
 import { quoteIdentifier } from '../../sql-utils';
 import type { SqlitePlanTargetDetails } from '../planner-target-details';
@@ -75,14 +76,6 @@ export interface SqliteIndexSpec {
   readonly columns: readonly string[];
 }
 
-const REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {
-  noAction: 'NO ACTION',
-  restrict: 'RESTRICT',
-  cascade: 'CASCADE',
-  setNull: 'SET NULL',
-  setDefault: 'SET DEFAULT',
-};
-
 /**
  * Renders a single column's inline DDL fragment within a `CREATE TABLE`
  * statement. Honours the `inlineAutoincrementPrimaryKey` flag — SQLite

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

@@ -61,7 +61,7 @@ export function tableAt(
   namespaceId: string,
   tableName: string,
 ): StorageTable | undefined {
-  return storage.namespaces[namespaceId]?.tables[tableName] as StorageTable | undefined;
+  return storage.namespaces[namespaceId]?.entries.table[tableName] as StorageTable | undefined;
 }
 
 /**

package/src/core/migrations/runner.ts

@@ -1,4 +1,4 @@
-import type { ContractMarkerRecord } from '@prisma-next/contract/types';
+import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
   SqlControlFamilyInstance,
@@ -13,27 +13,17 @@ import type {
 } 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 ContractMarkerRow, parseContractMarkerRow } from '@prisma-next/family-sql/verify';
-import type {
-  ControlDriverInstance,
-  MigrationRunnerResult,
-} from '@prisma-next/framework-components/control';
+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';
+import type { LoweredStatement } from '@prisma-next/sql-relational-core/ast';
 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 type { SqlitePlanTargetDetails } from './planner-target-details';
-import {
-  buildLedgerInsertStatement,
-  buildWriteMarkerStatements,
-  ensureLedgerTableStatement,
-  ensureMarkerTableStatement,
-  MARKER_TABLE_NAME,
-  readMarkerStatement,
-  type SqlStatement,
-} from './statement-builders';
 
 export function createSqliteMigrationRunner(
   family: SqlControlFamilyInstance,
@@ -70,9 +60,9 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
     if (!policyCheck.ok) return policyCheck;
 
-    const ensureResult = await this.ensureControlTables(driver);
+    const ensureResult = await this.ensureControlTables(driver, options.destinationContract);
     if (!ensureResult.ok) return ensureResult;
-    const existingMarker = await this.readMarker(driver, space);
+    const existingMarker = await this.family.readMarker({ driver, space });
 
     const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
     if (!markerCheck.ok) return markerCheck;
@@ -126,8 +116,9 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     const isSelfEdgeNoOp = isSelfEdge && operationsExecuted === 0 && incomingIsSubsetOfExisting;
 
     if (!isSelfEdgeNoOp) {
-      await this.upsertMarker(driver, options, existingMarker, space);
-      await this.recordLedgerEntry(driver, options, existingMarker, executedOperations);
+      const markerResult = await this.upsertMarker(driver, options, existingMarker, space);
+      if (!markerResult.ok) return markerResult;
+      await this.recordLedgerEntries(driver, options, executedOperations);
     }
 
     return runnerSuccess({
@@ -137,7 +128,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
   }
 
   async execute(options: {
-    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly driver: SqlControlDriverInstance<string>;
     readonly perSpaceOptions: ReadonlyArray<
       SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>
     >;
@@ -306,17 +297,16 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
 
   private async ensureControlTables(
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
+    contract: Contract<SqlStorage>,
   ): Promise<Result<void, SqlMigrationRunnerFailure>> {
-    // Pre-1.0 zero-range guardrail: detect a pre-cleanup single-row
-    // marker table (no `space` column) and surface a structured failure
-    // rather than silently rebuilding the table into the per-space
-    // shape. See `specs/framework-mechanism.spec.md § 2`.
     const legacyDetection = await this.detectLegacyMarkerShape(driver);
     if (!legacyDetection.ok) {
       return legacyDetection;
     }
-    await this.executeStatement(driver, ensureMarkerTableStatement);
-    await this.executeStatement(driver, ensureLedgerTableStatement);
+    const lowererContext = { contract };
+    for (const query of this.family.bootstrapControlTableQueries()) {
+      await this.executeStatement(driver, this.family.lowerAst(query, lowererContext));
+    }
     return okVoid();
   }
 
@@ -347,32 +337,6 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     );
   }
 
-  private async readMarker(
-    driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
-    space: string,
-  ): Promise<ContractMarkerRecord | null> {
-    const stmt = readMarkerStatement(space);
-    try {
-      const result = await driver.query<ContractMarkerRow>(stmt.sql, stmt.params);
-      const row = result.rows[0];
-      if (!row) return null;
-      // SQLite stores arrays as JSON-encoded TEXT (no native array type), so
-      // the driver returns `invariants` as a string. Decode before delegating
-      // to the shared row schema, which expects `string[]`.
-      const invariants =
-        typeof row.invariants === 'string'
-          ? (JSON.parse(row.invariants) as unknown)
-          : row.invariants;
-      return parseContractMarkerRow({ ...row, invariants });
-    } catch (error) {
-      // Table might not exist yet
-      if (error instanceof Error && error.message.includes('no such table')) {
-        return null;
-      }
-      throw error;
-    }
-  }
-
   private async runExpectationSteps(
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
     steps: readonly SqlMigrationPlanOperationStep[],
@@ -600,48 +564,79 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     options: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>,
     existingMarker: ContractMarkerRecord | null,
     space: string,
-  ): Promise<void> {
-    // SQLite has no native array type, so we can't merge invariants in SQL
-    // the way Postgres does. Merge client-side under the runner's
-    // BEGIN EXCLUSIVE — sort + dedupe so the JSON-encoded value is stable.
-    const merged = new Set<string>(existingMarker?.invariants ?? []);
-    for (const inv of options.plan.providedInvariants) merged.add(inv);
-    const invariants = Array.from(merged).sort();
-    const writeStatements = buildWriteMarkerStatements({
-      space,
+  ): Promise<Result<void, SqlMigrationRunnerFailure>> {
+    // Pass the plan's incoming invariants verbatim; `updateMarker` unions them
+    // with the stored set (TS-side, dialect-uniform) under the runner's
+    // BEGIN EXCLUSIVE — no client-side pre-merge here, so there is no
+    // double-merge with the SPI's internal accumulate-dedupe.
+    const destination = {
       storageHash: options.plan.destination.storageHash,
       profileHash:
         options.plan.destination.profileHash ??
         options.destinationContract.profileHash ??
         options.plan.destination.storageHash,
-      contractJson: options.destinationContract,
-      canonicalVersion: null,
-      meta: {},
-      invariants,
+      invariants: options.plan.providedInvariants ?? [],
+    };
+    if (!existingMarker) {
+      await this.family.initMarker({ driver, space, destination });
+      return okVoid();
+    }
+    const updated = await this.family.updateMarker({
+      driver,
+      space,
+      expectedFrom: existingMarker.storageHash,
+      destination,
     });
-    const statement = existingMarker ? writeStatements.update : writeStatements.insert;
-    await this.executeStatement(driver, statement);
+    if (!updated) {
+      return runnerFailure(
+        'MARKER_CAS_FAILURE',
+        'Marker was modified by another process during migration execution.',
+        {
+          meta: {
+            space,
+            expectedStorageHash: existingMarker.storageHash,
+            destinationStorageHash: options.plan.destination.storageHash,
+          },
+        },
+      );
+    }
+    return okVoid();
   }
 
-  private async recordLedgerEntry(
+  private async recordLedgerEntries(
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>,
-    existingMarker: ContractMarkerRecord | null,
     executedOperations: readonly SqlMigrationPlanOperation<SqlitePlanTargetDetails>[],
   ): Promise<void> {
-    const ledgerStatement = buildLedgerInsertStatement({
-      originStorageHash: existingMarker?.storageHash ?? null,
-      originProfileHash: existingMarker?.profileHash ?? null,
-      destinationStorageHash: options.plan.destination.storageHash,
-      destinationProfileHash:
-        options.plan.destination.profileHash ??
-        options.destinationContract.profileHash ??
-        options.plan.destination.storageHash,
-      contractJsonBefore: existingMarker?.contractJson ?? null,
-      contractJsonAfter: options.destinationContract,
-      operations: executedOperations,
-    });
-    await this.executeStatement(driver, ledgerStatement);
+    const plan = options.plan;
+    const space = plan.spaceId;
+    const edges = options.migrationEdges;
+    const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
+    if (totalEdgeOps !== plan.operations.length) {
+      throw new Error(
+        `Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
+      );
+    }
+    // The ledger records the operations as executed — idempotency-skipped ops
+    // are substituted with skip records (empty `execute`) by `applyPlan`, so the
+    // journal reflects what actually ran rather than the raw plan.
+    let offset = 0;
+    for (const edge of edges) {
+      const edgeOps = executedOperations.slice(offset, offset + edge.operationCount);
+      offset += edge.operationCount;
+      await this.family.writeLedgerEntry({
+        driver,
+        space,
+        entry: {
+          edgeId: `${edge.from}->${edge.to}`,
+          from: edge.from,
+          to: edge.to,
+          migrationName: edge.dirName,
+          migrationHash: edge.migrationHash,
+          operations: edgeOps,
+        },
+      });
+    }
   }
 
   private async beginExclusiveTransaction(
@@ -664,7 +659,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
 
   private async executeStatement(
     driver: SqlMigrationRunnerExecuteOptions<SqlitePlanTargetDetails>['driver'],
-    statement: SqlStatement,
+    statement: LoweredStatement,
   ): Promise<void> {
     if (statement.params.length > 0) {
       await driver.query(statement.sql, statement.params);

package/src/core/runtime-target.ts

@@ -1,6 +1,6 @@
 import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';
 import type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';
-import { sqliteTargetDescriptorMeta } from './descriptor-meta';
+import { sqliteTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
 
 export interface SqliteRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'sqlite'> {}
 
@@ -8,7 +8,7 @@ const sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<
   'sqlite',
   SqliteRuntimeTargetInstance
 > = {
-  ...sqliteTargetDescriptorMeta,
+  ...sqliteTargetDescriptorMetaRuntime,
   codecs: () => [],
   create(): SqliteRuntimeTargetInstance {
     return {

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

@@ -1,20 +1,32 @@
 import type { Contract } from '@prisma-next/contract/types';
 import { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';
-import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { type Namespace, NamespaceBase } from '@prisma-next/framework-components/ir';
+import type { SqlNamespaceTablesInput, SqlStorage } from '@prisma-next/sql-contract/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { buildSqliteNamespace } from './sqlite-unbound-database';
 
 /**
  * SQLite target `ContractSerializer` concretion. Mirrors the Postgres
- * shape: inherits the full SQL-family deserialization pipeline. Today's
- * SQLite contract shape is the family-shared shape; no target-specific
- * polymorphic `storage.types` factories are registered yet.
- *
- * `serializeContract` falls through to the family-base default —
- * SQLite's contract is JSON-clean today. Once target-only fields land
- * (e.g. per-target derived storage fields) this is the home for
- * stripping them from the persisted envelope.
+ * shape: inherits the full SQL-family deserialization pipeline and
+ * materialises namespace entries as SQLite database concretions that
+ * expose `qualifyTable()` for runtime SQL rendering.
  */
 export class SqliteContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor() {
     super(new Map());
   }
+
+  protected override hydrateSqlNamespaceEntry(
+    nsId: string,
+    raw: Namespace | Record<string, unknown>,
+  ): Namespace | SqlNamespaceTablesInput {
+    if (raw instanceof NamespaceBase) {
+      return raw;
+    }
+    const hydrated = blindCast<
+      SqlNamespaceTablesInput,
+      'super.hydrateSqlNamespaceEntry returns the tables form when raw is not a NamespaceBase'
+    >(super.hydrateSqlNamespaceEntry(nsId, raw));
+    return buildSqliteNamespace(hydrated);
+  }
 }

package/src/core/sqlite-unbound-database.ts

@@ -1,9 +1,81 @@
 import {
   freezeNode,
+  type Namespace,
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import type { StorageTable } from '@prisma-next/sql-contract/types';
+import {
+  type SqlNamespaceTablesInput,
+  StorageTable,
+  type StorageTableInput,
+} from '@prisma-next/sql-contract/types';
+import { blindCast, castAs } from '@prisma-next/utils/casts';
+
+export type SqliteDatabaseInput = {
+  readonly id: string;
+  readonly entries: {
+    readonly table: Readonly<Record<string, StorageTable | StorageTableInput>>;
+  };
+};
+
+const SQLITE_NAMESPACE_KIND = 'sqlite-namespace' as const;
+
+function isMaterializedSqliteNamespace(
+  ns: Namespace | SqlNamespaceTablesInput,
+): ns is SqliteDatabase | SqliteUnboundDatabase {
+  if (typeof ns !== 'object' || ns === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(ns);
+  if (proto === Object.prototype || proto === null) {
+    return false;
+  }
+  return (ns as { kind?: unknown }).kind === SQLITE_NAMESPACE_KIND;
+}
+
+/**
+ * SQLite namespace concretion carrying table metadata under
+ * `entries.table` and unqualified `qualifyTable()` emission for runtime
+ * SQL rendering.
+ */
+export class SqliteDatabase extends NamespaceBase {
+  declare readonly kind: string;
+
+  readonly id: string;
+  readonly entries: Readonly<{
+    readonly table: Readonly<Record<string, StorageTable>>;
+  }>;
+
+  constructor(input: SqliteDatabaseInput) {
+    super();
+    this.id = input.id;
+    this.entries = Object.freeze({
+      table: Object.freeze(
+        Object.fromEntries(
+          Object.entries(input.entries.table).map(([k, v]) => [
+            k,
+            v instanceof StorageTable ? v : new StorageTable(v as StorageTableInput),
+          ]),
+        ),
+      ),
+    });
+    Object.defineProperty(this, 'kind', {
+      value: SQLITE_NAMESPACE_KIND,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    });
+    freezeNode(this);
+  }
+
+  qualifier(): string {
+    return '';
+  }
+
+  qualifyTable(tableName: string): string {
+    return `"${tableName}"`;
+  }
+}
 
 /**
  * SQLite target `Namespace` concretion. SQLite has no schema or
@@ -22,43 +94,58 @@ import type { StorageTable } from '@prisma-next/sql-contract/types';
  * `__unspecified__` AST bucket reaches the SQLite interpreter, which
  * lowers it to this singleton.
  */
-export class SqliteUnboundDatabase extends NamespaceBase {
+export class SqliteUnboundDatabase extends SqliteDatabase {
   static readonly instance: SqliteUnboundDatabase = new SqliteUnboundDatabase();
 
-  readonly kind = 'database' as const;
-  readonly id = UNBOUND_NAMESPACE_ID;
-  readonly tables: Readonly<Record<string, StorageTable>>;
-
   private constructor() {
-    super();
-    this.tables = Object.freeze({});
-    freezeNode(this);
+    super({ id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });
   }
+}
 
-  qualifier(): string {
-    return '';
+export function buildSqliteNamespace(
+  input: SqlNamespaceTablesInput,
+): SqliteDatabase | SqliteUnboundDatabase {
+  if (input.id !== UNBOUND_NAMESPACE_ID) {
+    throw new Error(
+      `buildSqliteNamespace: SQLite has no schema concept; the only valid namespace id is "${UNBOUND_NAMESPACE_ID}" (received "${input.id}").`,
+    );
   }
-
-  qualifyTable(tableName: string): string {
-    return `"${tableName}"`;
+  if (Object.keys(input.entries.table).length === 0) {
+    return castAs<SqliteUnboundDatabase>(SqliteUnboundDatabase.instance);
   }
+  return new SqliteDatabase({ id: input.id, entries: input.entries });
+}
+
+export function buildSqliteNamespaceMap(
+  namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>,
+): Readonly<Record<string, SqliteDatabase | SqliteUnboundDatabase>> {
+  return Object.fromEntries(
+    Object.entries(namespaces).map(([nsKey, ns]) => [
+      nsKey,
+      isMaterializedSqliteNamespace(ns)
+        ? ns
+        : buildSqliteNamespace(
+            blindCast<
+              SqlNamespaceTablesInput,
+              'non-materialized SQLite namespace map entry is a SqlNamespaceTablesInput'
+            >(ns),
+          ),
+    ]),
+  );
 }
 
 /**
  * Target-supplied `Namespace` factory the SQLite target plumbs through
  * `defineContract({ createNamespace })`. SQLite has only one
  * effective namespace slot — the framework `UNBOUND_NAMESPACE_ID`
- * sentinel — so the factory always returns the singleton and rejects
- * any other coordinate. The SQL family's defensive validation in
- * `defineContract` already rejects user-declared SQLite namespaces, so
- * this throw is a structural safety net rather than a user-facing
- * surface.
+ * sentinel — so the factory always returns the singleton or a fresh
+ * `SqliteDatabase` for the unbound slot with tables. The SQL family's
+ * defensive validation in `defineContract` already rejects
+ * user-declared SQLite namespaces, so this throw is a structural
+ * safety net rather than a user-facing surface.
  */
-export function sqliteCreateNamespace(id: string): SqliteUnboundDatabase {
-  if (id === UNBOUND_NAMESPACE_ID) {
-    return SqliteUnboundDatabase.instance;
-  }
-  throw new Error(
-    `sqliteCreateNamespace: SQLite has no schema concept; the only valid namespace id is "${UNBOUND_NAMESPACE_ID}" (received "${id}").`,
-  );
+export function sqliteCreateNamespace(
+  input: SqlNamespaceTablesInput,
+): SqliteDatabase | SqliteUnboundDatabase {
+  return buildSqliteNamespace(input);
 }

package/src/exports/contract-free.ts

@@ -0,0 +1,6 @@
+export { datetime, integer, jsonText, sqliteTable, text } from '../contract-free/columns';
+export {
+  buildControlTableBootstrapQueries,
+  buildSignMarkerBootstrapQueries,
+} from '../contract-free/control-bootstrap';
+export { createTable } from '../contract-free/ddl';

package/src/exports/control-tables.ts

@@ -0,0 +1,5 @@
+export {
+  CONTROL_TABLE_NAMES,
+  LEDGER_TABLE_NAME,
+  MARKER_TABLE_NAME,
+} from '../core/control-tables';