@prisma-next/target-sqlite 0.12.0-dev.3 → 0.12.0-dev.30

package/dist/sqlite-contract-serializer-Hy7WQPea.mjs

@@ -0,0 +1,100 @@
+import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode } from "@prisma-next/framework-components/ir";
+import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
+//#region src/core/sqlite-unbound-database.ts
+/**
+* SQLite namespace concretion carrying table metadata and unqualified
+* `qualifyTable()` emission for runtime SQL rendering.
+*/
+var SqliteDatabase = class extends NamespaceBase {
+	kind = "database";
+	id;
+	tables;
+	constructor(input) {
+		super();
+		this.id = input.id;
+		this.tables = Object.freeze({ ...input.tables });
+		freezeNode(this);
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyTable(tableName) {
+		return `"${tableName}"`;
+	}
+};
+/**
+* SQLite target `Namespace` concretion. SQLite has no schema or
+* database-namespacing concept at the SQL level — there is exactly one
+* effective namespace per connection, so the target ships a single
+* singleton bound to the framework's `UNBOUND_NAMESPACE_ID` slot.
+*
+* Qualifier emission elides the prefix entirely: rendered DDL and
+* queries look unqualified (`CREATE TABLE "users" (...)`), matching
+* SQLite's native dialect. Call sites stay polymorphic — they ask the
+* namespace for its qualifier and consume the empty/unqualified result
+* the same way Postgres consumes a `"schema"` prefix.
+*
+* The SQLite PSL interpreter rejects every explicit `namespace { … }`
+* block with a diagnostic naming SQLite; only the implicit
+* `__unspecified__` AST bucket reaches the SQLite interpreter, which
+* lowers it to this singleton.
+*/
+var SqliteUnboundDatabase = class SqliteUnboundDatabase extends NamespaceBase {
+	static instance = new SqliteUnboundDatabase();
+	kind = "database";
+	id = UNBOUND_NAMESPACE_ID;
+	tables;
+	constructor() {
+		super();
+		this.tables = Object.freeze({});
+		freezeNode(this);
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyTable(tableName) {
+		return `"${tableName}"`;
+	}
+};
+/**
+* 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.
+*/
+function sqliteCreateNamespace(id) {
+	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}").`);
+}
+//#endregion
+//#region src/core/sqlite-contract-serializer.ts
+/**
+* SQLite target `ContractSerializer` concretion. Mirrors the Postgres
+* shape: inherits the full SQL-family deserialization pipeline and
+* materialises namespace entries as SQLite database concretions that
+* expose `qualifyTable()` for runtime SQL rendering.
+*/
+var SqliteContractSerializer = class extends SqlContractSerializerBase {
+	constructor() {
+		super(/* @__PURE__ */ new Map());
+	}
+	hydrateSqlNamespaceEntry(nsId, raw) {
+		if (raw instanceof NamespaceBase) return raw;
+		const { id, tables } = super.hydrateSqlNamespaceEntry(nsId, raw);
+		const emptyTables = Object.keys(tables).length === 0;
+		if (id === UNBOUND_NAMESPACE_ID && emptyTables) return SqliteUnboundDatabase.instance;
+		if (id !== UNBOUND_NAMESPACE_ID) throw new Error(`SqliteContractSerializer: SQLite has no schema concept; the only valid namespace id is "${UNBOUND_NAMESPACE_ID}" (received "${id}").`);
+		return new SqliteDatabase({
+			id,
+			tables
+		});
+	}
+};
+//#endregion
+export { SqliteUnboundDatabase as n, sqliteCreateNamespace as r, SqliteContractSerializer as t };
+
+//# sourceMappingURL=sqlite-contract-serializer-Hy7WQPea.mjs.map

package/dist/sqlite-contract-serializer-Hy7WQPea.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-contract-serializer-Hy7WQPea.mjs","names":[],"sources":["../src/core/sqlite-unbound-database.ts","../src/core/sqlite-contract-serializer.ts"],"sourcesContent":["import {\n  freezeNode,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport type { StorageTable } from '@prisma-next/sql-contract/types';\n\nexport type SqliteDatabaseInput = {\n  readonly id: string;\n  readonly tables: Readonly<Record<string, StorageTable>>;\n};\n\n/**\n * SQLite namespace concretion carrying table metadata and unqualified\n * `qualifyTable()` emission for runtime SQL rendering.\n */\nexport class SqliteDatabase extends NamespaceBase {\n  readonly kind = 'database' as const;\n  readonly id: string;\n  readonly tables: Readonly<Record<string, StorageTable>>;\n\n  constructor(input: SqliteDatabaseInput) {\n    super();\n    this.id = input.id;\n    this.tables = Object.freeze({ ...input.tables });\n    freezeNode(this);\n  }\n\n  qualifier(): string {\n    return '';\n  }\n\n  qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n}\n\n/**\n * SQLite target `Namespace` concretion. SQLite has no schema or\n * database-namespacing concept at the SQL level — there is exactly one\n * effective namespace per connection, so the target ships a single\n * singleton bound to the framework's `UNBOUND_NAMESPACE_ID` slot.\n *\n * Qualifier emission elides the prefix entirely: rendered DDL and\n * queries look unqualified (`CREATE TABLE \"users\" (...)`), matching\n * SQLite's native dialect. Call sites stay polymorphic — they ask the\n * namespace for its qualifier and consume the empty/unqualified result\n * the same way Postgres consumes a `\"schema\"` prefix.\n *\n * The SQLite PSL interpreter rejects every explicit `namespace { … }`\n * block with a diagnostic naming SQLite; only the implicit\n * `__unspecified__` AST bucket reaches the SQLite interpreter, which\n * lowers it to this singleton.\n */\nexport class SqliteUnboundDatabase extends NamespaceBase {\n  static readonly instance: SqliteUnboundDatabase = new SqliteUnboundDatabase();\n\n  readonly kind = 'database' as const;\n  readonly id = UNBOUND_NAMESPACE_ID;\n  readonly tables: Readonly<Record<string, StorageTable>>;\n\n  private constructor() {\n    super();\n    this.tables = Object.freeze({});\n    freezeNode(this);\n  }\n\n  qualifier(): string {\n    return '';\n  }\n\n  qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n}\n\n/**\n * Target-supplied `Namespace` factory the SQLite target plumbs through\n * `defineContract({ createNamespace })`. SQLite has only one\n * effective namespace slot — the framework `UNBOUND_NAMESPACE_ID`\n * sentinel — so the factory always returns the singleton and rejects\n * any other coordinate. The SQL family's defensive validation in\n * `defineContract` already rejects user-declared SQLite namespaces, so\n * this throw is a structural safety net rather than a user-facing\n * surface.\n */\nexport function sqliteCreateNamespace(id: string): SqliteUnboundDatabase {\n  if (id === UNBOUND_NAMESPACE_ID) {\n    return SqliteUnboundDatabase.instance;\n  }\n  throw new Error(\n    `sqliteCreateNamespace: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${id}\").`,\n  );\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';\nimport {\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport type {\n  SqlNamespaceTablesInput,\n  SqlStorage,\n  StorageTable,\n} from '@prisma-next/sql-contract/types';\nimport { SqliteDatabase, SqliteUnboundDatabase } from './sqlite-unbound-database';\n\n/**\n * SQLite target `ContractSerializer` concretion. Mirrors the Postgres\n * shape: inherits the full SQL-family deserialization pipeline and\n * materialises namespace entries as SQLite database concretions that\n * expose `qualifyTable()` for runtime SQL rendering.\n */\nexport class SqliteContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor() {\n    super(new Map());\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Namespace | Record<string, unknown>,\n  ): Namespace | SqlNamespaceTablesInput {\n    if (raw instanceof NamespaceBase) {\n      return raw;\n    }\n    const hydrated = super.hydrateSqlNamespaceEntry(nsId, raw) as {\n      id: string;\n      tables: Readonly<Record<string, StorageTable>>;\n    };\n    const { id, tables } = hydrated;\n    const emptyTables = Object.keys(tables).length === 0;\n    if (id === UNBOUND_NAMESPACE_ID && emptyTables) {\n      return SqliteUnboundDatabase.instance;\n    }\n    if (id !== UNBOUND_NAMESPACE_ID) {\n      throw new Error(\n        `SqliteContractSerializer: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${id}\").`,\n      );\n    }\n    return new SqliteDatabase({ id, tables });\n  }\n}\n"],"mappings":";;;;;;;AAgBA,IAAa,iBAAb,cAAoC,cAAc;CAChD,OAAgB;CAChB;CACA;CAEA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAChB,KAAK,SAAS,OAAO,OAAO,EAAE,GAAG,MAAM,OAAO,CAAC;EAC/C,WAAW,IAAI;CACjB;CAEA,YAAoB;EAClB,OAAO;CACT;CAEA,aAAa,WAA2B;EACtC,OAAO,IAAI,UAAU;CACvB;AACF;;;;;;;;;;;;;;;;;;AAmBA,IAAa,wBAAb,MAAa,8BAA8B,cAAc;CACvD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,OAAgB;CAChB,KAAc;CACd;CAEA,cAAsB;EACpB,MAAM;EACN,KAAK,SAAS,OAAO,OAAO,CAAC,CAAC;EAC9B,WAAW,IAAI;CACjB;CAEA,YAAoB;EAClB,OAAO;CACT;CAEA,aAAa,WAA2B;EACtC,OAAO,IAAI,UAAU;CACvB;AACF;;;;;;;;;;;AAYA,SAAgB,sBAAsB,IAAmC;CACvE,IAAI,OAAO,sBACT,OAAO,sBAAsB;CAE/B,MAAM,IAAI,MACR,wFAAwF,qBAAqB,eAAe,GAAG,IACjI;AACF;;;;;;;;;ACzEA,IAAa,2BAAb,cAA8C,0BAAgD;CAC5F,cAAc;EACZ,sBAAM,IAAI,IAAI,CAAC;CACjB;CAEA,yBACE,MACA,KACqC;EACrC,IAAI,eAAe,eACjB,OAAO;EAMT,MAAM,EAAE,IAAI,WAJK,MAAM,yBAAyB,MAAM,GAIxB;EAC9B,MAAM,cAAc,OAAO,KAAK,MAAM,EAAE,WAAW;EACnD,IAAI,OAAO,wBAAwB,aACjC,OAAO,sBAAsB;EAE/B,IAAI,OAAO,sBACT,MAAM,IAAI,MACR,2FAA2F,qBAAqB,eAAe,GAAG,IACpI;EAEF,OAAO,IAAI,eAAe;GAAE;GAAI;EAAO,CAAC;CAC1C;AACF"}

package/dist/{sqlite-migration-Feio34n3.d.mts → sqlite-migration-D-O3Glz1.d.mts}

@@ -1,4 +1,4 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-B-VJkUsu.mjs";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-RVPqF2ug.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
 
 //#region src/core/migrations/sqlite-migration.d.ts
@@ -14,4 +14,4 @@ declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails
 }
 //#endregion
 export { SqliteMigration as t };
-//# sourceMappingURL=sqlite-migration-Feio34n3.d.mts.map
+//# sourceMappingURL=sqlite-migration-D-O3Glz1.d.mts.map

package/dist/{sqlite-migration-Feio34n3.d.mts.map → sqlite-migration-D-O3Glz1.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"sqlite-migration-Feio34n3.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;AAUA;;;;;uBAAsB,eAAA,SAAwB,SAAY,CAAC,uBAAA;EAAA,SAChD,QAAA;AAAA"}
+{"version":3,"file":"sqlite-migration-D-O3Glz1.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"mappings":";;;;;;AAUA;;;;;uBAAsB,eAAA,SAAwB,SAAY,CAAC,uBAAA;EAAA,SAChD,QAAA;AAAA"}

package/dist/{statement-builders-BiRmeyJM.mjs → statement-builders-D1Q_i4sb.mjs}

@@ -33,7 +33,10 @@ const ensureMarkerTableStatement = {
 const ensureLedgerTableStatement = {
 	sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+    space TEXT NOT NULL,
+    migration_name TEXT NOT NULL,
+    migration_hash TEXT NOT NULL,
     origin_core_hash TEXT,
     origin_profile_hash TEXT,
     destination_core_hash TEXT NOT NULL,
@@ -122,6 +125,9 @@ function buildWriteMarkerStatements(input) {
 function buildLedgerInsertStatement(input) {
 	return {
 		sql: `INSERT INTO _prisma_ledger (
+      space,
+      migration_name,
+      migration_hash,
       origin_core_hash,
       origin_profile_hash,
       destination_core_hash,
@@ -136,9 +142,15 @@ function buildLedgerInsertStatement(input) {
       ?,
       ?,
       ?,
+      ?,
+      ?,
+      ?,
       ?
     )`,
 		params: [
+			input.space,
+			input.migrationName,
+			input.migrationHash,
 			input.originStorageHash ?? null,
 			input.originProfileHash ?? null,
 			input.destinationStorageHash,
@@ -155,4 +167,4 @@ function jsonParam(value) {
 //#endregion
 export { buildLedgerInsertStatement as a, ensureMarkerTableStatement as c, MARKER_TABLE_NAME as i, readMarkerStatement as l, CONTROL_TABLE_NAMES as n, buildWriteMarkerStatements as o, LEDGER_TABLE_NAME as r, ensureLedgerTableStatement as s, APP_SPACE_ID$1 as t };
 
-//# sourceMappingURL=statement-builders-BiRmeyJM.mjs.map
+//# sourceMappingURL=statement-builders-D1Q_i4sb.mjs.map

package/dist/statement-builders-D1Q_i4sb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-builders-D1Q_i4sb.mjs","names":["APP_SPACE_ID"],"sources":["../src/core/migrations/statement-builders.ts"],"sourcesContent":["import { APP_SPACE_ID } from '@prisma-next/framework-components/control';\n\nexport { APP_SPACE_ID };\n\nexport interface SqlStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n}\n\nexport const MARKER_TABLE_NAME = '_prisma_marker';\nexport const LEDGER_TABLE_NAME = '_prisma_ledger';\n\n/**\n * Control tables the runner creates/manages. The planner must not drop these\n * when reconciling \"extra\" tables against the contract.\n */\nexport const CONTROL_TABLE_NAMES: ReadonlySet<string> = new Set([\n  MARKER_TABLE_NAME,\n  LEDGER_TABLE_NAME,\n]);\n\n/**\n * Schema for `_prisma_marker`. The `space TEXT PRIMARY KEY` shape\n * supports one row per loaded contract space (`'app'`,\n * `'<extension-id>'`, …); brand-new databases create this shape\n * directly. The migration runner detects pre-1.0 single-row markers\n * (no `space` column) at boot and fails with a structured\n * `LEGACY_MARKER_SHAPE` error rather than auto-rebuilding the table —\n * see `specs/framework-mechanism.spec.md § 2`.\n */\nexport const ensureMarkerTableStatement: SqlStatement = {\n  sql: `CREATE TABLE IF NOT EXISTS _prisma_marker (\n    space TEXT NOT NULL PRIMARY KEY DEFAULT '${APP_SPACE_ID}',\n    core_hash TEXT NOT NULL,\n    profile_hash TEXT NOT NULL,\n    contract_json TEXT,\n    canonical_version INTEGER,\n    updated_at TEXT NOT NULL DEFAULT (datetime('now')),\n    app_tag TEXT,\n    meta TEXT NOT NULL DEFAULT '{}',\n    invariants TEXT NOT NULL DEFAULT '[]'\n  )`,\n  params: [],\n};\n\nexport const ensureLedgerTableStatement: SqlStatement = {\n  sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),\n    space TEXT NOT NULL,\n    migration_name TEXT NOT NULL,\n    migration_hash TEXT NOT NULL,\n    origin_core_hash TEXT,\n    origin_profile_hash TEXT,\n    destination_core_hash TEXT NOT NULL,\n    destination_profile_hash TEXT,\n    contract_json_before TEXT,\n    contract_json_after TEXT,\n    operations TEXT NOT NULL\n  )`,\n  params: [],\n};\n\nexport function readMarkerStatement(space: string): SqlStatement {\n  return {\n    sql: `SELECT\n      core_hash,\n      profile_hash,\n      contract_json,\n      canonical_version,\n      updated_at,\n      app_tag,\n      meta,\n      invariants\n    FROM _prisma_marker\n    WHERE space = ?`,\n    params: [space],\n  };\n}\n\nexport interface WriteMarkerInput {\n  /**\n   * Logical space identifier for this marker row. Required at every\n   * call site so the type system surfaces every place that needs to\n   * thread the value (rather than letting an `?? APP_SPACE_ID`\n   * fall-through silently collapse per-space markers onto the\n   * `'app'` row). App-plan callers pass {@link APP_SPACE_ID}\n   * (`'app'`); per-extension callers pass the extension's space id.\n   */\n  readonly space: string;\n  readonly storageHash: string;\n  readonly profileHash: string;\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n  /**\n   * Invariants to write into `marker.invariants`. Stored as a JSON-encoded\n   * TEXT array — SQLite has no native array type. The runner is responsible\n   * for merging with the existing column (no SQL-side merge here, unlike\n   * Postgres) before passing them in: BEGIN EXCLUSIVE on the migration\n   * transaction makes the read-then-merge-then-write sequence safe.\n   */\n  readonly invariants: readonly string[];\n}\n\nexport function buildWriteMarkerStatements(input: WriteMarkerInput): {\n  readonly insert: SqlStatement;\n  readonly update: SqlStatement;\n} {\n  const params: readonly unknown[] = [\n    input.space,\n    input.storageHash,\n    input.profileHash,\n    jsonParam(input.contractJson),\n    input.canonicalVersion ?? null,\n    input.appTag ?? null,\n    jsonParam(input.meta ?? {}),\n    jsonParam(input.invariants),\n  ];\n\n  return {\n    insert: {\n      sql: `INSERT INTO _prisma_marker (\n        space,\n        core_hash,\n        profile_hash,\n        contract_json,\n        canonical_version,\n        updated_at,\n        app_tag,\n        meta,\n        invariants\n      ) VALUES (\n        ?,\n        ?,\n        ?,\n        ?,\n        ?,\n        datetime('now'),\n        ?,\n        ?,\n        ?\n      )`,\n      params,\n    },\n    update: {\n      sql: `UPDATE _prisma_marker SET\n        core_hash = ?,\n        profile_hash = ?,\n        contract_json = ?,\n        canonical_version = ?,\n        updated_at = datetime('now'),\n        app_tag = ?,\n        meta = ?,\n        invariants = ?\n      WHERE space = ?`,\n      params: [\n        input.storageHash,\n        input.profileHash,\n        jsonParam(input.contractJson),\n        input.canonicalVersion ?? null,\n        input.appTag ?? null,\n        jsonParam(input.meta ?? {}),\n        jsonParam(input.invariants),\n        input.space,\n      ],\n    },\n  };\n}\n\nexport interface LedgerInsertInput {\n  readonly space: string;\n  readonly migrationName: string;\n  readonly migrationHash: string;\n  readonly originStorageHash?: string | null;\n  readonly originProfileHash?: string | null;\n  readonly destinationStorageHash: string;\n  readonly destinationProfileHash?: string | null;\n  readonly contractJsonBefore?: unknown;\n  readonly contractJsonAfter?: unknown;\n  readonly operations: unknown;\n}\n\nexport function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {\n  return {\n    sql: `INSERT INTO _prisma_ledger (\n      space,\n      migration_name,\n      migration_hash,\n      origin_core_hash,\n      origin_profile_hash,\n      destination_core_hash,\n      destination_profile_hash,\n      contract_json_before,\n      contract_json_after,\n      operations\n    ) VALUES (\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?,\n      ?\n    )`,\n    params: [\n      input.space,\n      input.migrationName,\n      input.migrationHash,\n      input.originStorageHash ?? null,\n      input.originProfileHash ?? null,\n      input.destinationStorageHash,\n      input.destinationProfileHash ?? null,\n      jsonParam(input.contractJsonBefore),\n      jsonParam(input.contractJsonAfter),\n      jsonParam(input.operations),\n    ],\n  };\n}\n\nfunction jsonParam(value: unknown): string {\n  return JSON.stringify(value ?? null);\n}\n"],"mappings":";;AASA,MAAa,oBAAoB;AACjC,MAAa,oBAAoB;;;;;AAMjC,MAAa,sBAA2C,IAAI,IAAI,CAC9D,mBACA,iBACF,CAAC;;;;;;;;;;AAWD,MAAa,6BAA2C;CACtD,KAAK;+CACwCA,eAAa;;;;;;;;;;CAU1D,QAAQ,CAAC;AACX;AAEA,MAAa,6BAA2C;CACtD,KAAK;;;;;;;;;;;;;;CAcL,QAAQ,CAAC;AACX;AAEA,SAAgB,oBAAoB,OAA6B;CAC/D,OAAO;EACL,KAAK;;;;;;;;;;;EAWL,QAAQ,CAAC,KAAK;CAChB;AACF;AA4BA,SAAgB,2BAA2B,OAGzC;CAYA,OAAO;EACL,QAAQ;GACN,KAAK;;;;;;;;;;;;;;;;;;;;;GAqBL,QAAA;IAjCF,MAAM;IACN,MAAM;IACN,MAAM;IACN,UAAU,MAAM,YAAY;IAC5B,MAAM,oBAAoB;IAC1B,MAAM,UAAU;IAChB,UAAU,MAAM,QAAQ,CAAC,CAAC;IAC1B,UAAU,MAAM,UAAU;GA0BnB;EACP;EACA,QAAQ;GACN,KAAK;;;;;;;;;;GAUL,QAAQ;IACN,MAAM;IACN,MAAM;IACN,UAAU,MAAM,YAAY;IAC5B,MAAM,oBAAoB;IAC1B,MAAM,UAAU;IAChB,UAAU,MAAM,QAAQ,CAAC,CAAC;IAC1B,UAAU,MAAM,UAAU;IAC1B,MAAM;GACR;EACF;CACF;AACF;AAeA,SAAgB,2BAA2B,OAAwC;CACjF,OAAO;EACL,KAAK;;;;;;;;;;;;;;;;;;;;;;;EAuBL,QAAQ;GACN,MAAM;GACN,MAAM;GACN,MAAM;GACN,MAAM,qBAAqB;GAC3B,MAAM,qBAAqB;GAC3B,MAAM;GACN,MAAM,0BAA0B;GAChC,UAAU,MAAM,kBAAkB;GAClC,UAAU,MAAM,iBAAiB;GACjC,UAAU,MAAM,UAAU;EAC5B;CACF;AACF;AAEA,SAAS,UAAU,OAAwB;CACzC,OAAO,KAAK,UAAU,SAAS,IAAI;AACrC"}

package/dist/statement-builders.d.mts

@@ -54,6 +54,9 @@ declare function buildWriteMarkerStatements(input: WriteMarkerInput): {
   readonly update: SqlStatement;
 };
 interface LedgerInsertInput {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
   readonly originStorageHash?: string | null;
   readonly originProfileHash?: string | null;
   readonly destinationStorageHash: string;

package/dist/statement-builders.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"statement-builders.d.mts","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"mappings":";;;UAIiB,YAAA;EAAA,SACN,GAAA;EAAA,SACA,MAAM;AAAA;AAAA,cAGJ,iBAAA;AAAA,cACA,iBAAA;AADb;;;;AAAA,cAOa,mBAAA,EAAqB,WAAW;AAN7C;;;;AAA8B;AAM9B;;;;AANA,cAoBa,0BAAA,EAA4B,YAaxC;AAAA,cAEY,0BAAA,EAA4B,YAaxC;AAAA,iBAEe,mBAAA,CAAoB,KAAA,WAAgB,YAAY;AAAA,UAiB/C,gBAAA;EAlChB;AAAA;AAED;;;;AAaC;AAED;EAjBC,SA2CU,KAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA;EAAA,SACA,gBAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA,GAAO,MAAM;EAAA;;;;;;;EAAA,SAQb,UAAA;AAAA;AAAA,iBAGK,0BAAA,CAA2B,KAAA,EAAO,gBAAA;EAAA,SACvC,MAAA,EAAQ,YAAA;EAAA,SACR,MAAA,EAAQ,YAAA;AAAA;AAAA,UA+DF,iBAAA;EAAA,SACN,iBAAA;EAAA,SACA,iBAAA;EAAA,SACA,sBAAA;EAAA,SACA,sBAAA;EAAA,SACA,kBAAA;EAAA,SACA,iBAAA;EAAA,SACA,UAAA;AAAA;AAAA,iBAGK,0BAAA,CAA2B,KAAA,EAAO,iBAAA,GAAoB,YAAY"}
+{"version":3,"file":"statement-builders.d.mts","names":[],"sources":["../src/core/migrations/statement-builders.ts"],"mappings":";;;UAIiB,YAAA;EAAA,SACN,GAAA;EAAA,SACA,MAAM;AAAA;AAAA,cAGJ,iBAAA;AAAA,cACA,iBAAA;AADb;;;;AAAA,cAOa,mBAAA,EAAqB,WAAW;AAN7C;;;;AAA8B;AAM9B;;;;AANA,cAoBa,0BAAA,EAA4B,YAaxC;AAAA,cAEY,0BAAA,EAA4B,YAgBxC;AAAA,iBAEe,mBAAA,CAAoB,KAAA,WAAgB,YAAY;AAAA,UAiB/C,gBAAA;EArChB;AAAA;AAED;;;;AAgBC;AAED;EApBC,SA8CU,KAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA;EAAA,SACA,gBAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA,GAAO,MAAM;EAAA;;;;;;;EAAA,SAQb,UAAA;AAAA;AAAA,iBAGK,0BAAA,CAA2B,KAAA,EAAO,gBAAA;EAAA,SACvC,MAAA,EAAQ,YAAA;EAAA,SACR,MAAA,EAAQ,YAAA;AAAA;AAAA,UA+DF,iBAAA;EAAA,SACN,KAAA;EAAA,SACA,aAAA;EAAA,SACA,aAAA;EAAA,SACA,iBAAA;EAAA,SACA,iBAAA;EAAA,SACA,sBAAA;EAAA,SACA,sBAAA;EAAA,SACA,kBAAA;EAAA,SACA,iBAAA;EAAA,SACA,UAAA;AAAA;AAAA,iBAGK,0BAAA,CAA2B,KAAA,EAAO,iBAAA,GAAoB,YAAY"}

package/dist/statement-builders.mjs

@@ -1,2 +1,2 @@
-import { a as buildLedgerInsertStatement, c as ensureMarkerTableStatement, i as MARKER_TABLE_NAME, l as readMarkerStatement, n as CONTROL_TABLE_NAMES, o as buildWriteMarkerStatements, r as LEDGER_TABLE_NAME, s as ensureLedgerTableStatement, t as APP_SPACE_ID } from "./statement-builders-BiRmeyJM.mjs";
+import { a as buildLedgerInsertStatement, c as ensureMarkerTableStatement, i as MARKER_TABLE_NAME, l as readMarkerStatement, n as CONTROL_TABLE_NAMES, o as buildWriteMarkerStatements, r as LEDGER_TABLE_NAME, s as ensureLedgerTableStatement, t as APP_SPACE_ID } from "./statement-builders-D1Q_i4sb.mjs";
 export { APP_SPACE_ID, CONTROL_TABLE_NAMES, LEDGER_TABLE_NAME, MARKER_TABLE_NAME, buildLedgerInsertStatement, buildWriteMarkerStatements, ensureLedgerTableStatement, ensureMarkerTableStatement, readMarkerStatement };

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.12.0-dev.3",
+  "version": "0.12.0-dev.30",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.12.0-dev.3",
-    "@prisma-next/contract": "0.12.0-dev.3",
-    "@prisma-next/errors": "0.12.0-dev.3",
-    "@prisma-next/family-sql": "0.12.0-dev.3",
-    "@prisma-next/framework-components": "0.12.0-dev.3",
-    "@prisma-next/migration-tools": "0.12.0-dev.3",
-    "@prisma-next/sql-contract": "0.12.0-dev.3",
-    "@prisma-next/sql-errors": "0.12.0-dev.3",
-    "@prisma-next/sql-relational-core": "0.12.0-dev.3",
-    "@prisma-next/sql-runtime": "0.12.0-dev.3",
-    "@prisma-next/sql-schema-ir": "0.12.0-dev.3",
-    "@prisma-next/ts-render": "0.12.0-dev.3",
-    "@prisma-next/utils": "0.12.0-dev.3",
+    "@prisma-next/cli": "0.12.0-dev.30",
+    "@prisma-next/contract": "0.12.0-dev.30",
+    "@prisma-next/errors": "0.12.0-dev.30",
+    "@prisma-next/family-sql": "0.12.0-dev.30",
+    "@prisma-next/framework-components": "0.12.0-dev.30",
+    "@prisma-next/migration-tools": "0.12.0-dev.30",
+    "@prisma-next/sql-contract": "0.12.0-dev.30",
+    "@prisma-next/sql-errors": "0.12.0-dev.30",
+    "@prisma-next/sql-relational-core": "0.12.0-dev.30",
+    "@prisma-next/sql-runtime": "0.12.0-dev.30",
+    "@prisma-next/sql-schema-ir": "0.12.0-dev.30",
+    "@prisma-next/ts-render": "0.12.0-dev.30",
+    "@prisma-next/utils": "0.12.0-dev.30",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.12.0-dev.3",
-    "@prisma-next/test-utils": "0.12.0-dev.3",
-    "@prisma-next/tsconfig": "0.12.0-dev.3",
-    "@prisma-next/tsdown": "0.12.0-dev.3",
+    "@prisma-next/driver-sqlite": "0.12.0-dev.30",
+    "@prisma-next/test-utils": "0.12.0-dev.30",
+    "@prisma-next/tsconfig": "0.12.0-dev.30",
+    "@prisma-next/tsdown": "0.12.0-dev.30",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"
@@ -45,7 +45,9 @@
     "./codec-ids": "./dist/codec-ids.mjs",
     "./codec-types": "./dist/codec-types.mjs",
     "./codecs": "./dist/codecs.mjs",
+    "./contract-free": "./dist/contract-free.mjs",
     "./control": "./dist/control.mjs",
+    "./ddl": "./dist/ddl.mjs",
     "./default-normalizer": "./dist/default-normalizer.mjs",
     "./migration": "./dist/migration.mjs",
     "./native-type-normalizer": "./dist/native-type-normalizer.mjs",

package/src/contract-free/control-bootstrap.ts

@@ -0,0 +1,54 @@
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
+import type { DdlNode } from '@prisma-next/sql-relational-core/ast';
+import { col, fn, lit } from '@prisma-next/sql-relational-core/contract-free';
+import { createTable } from './ddl';
+
+const markerColumns = [
+  col('space', 'TEXT', { notNull: true, primaryKey: true, default: lit(APP_SPACE_ID) }),
+  col('core_hash', 'TEXT', { notNull: true }),
+  col('profile_hash', 'TEXT', { notNull: true }),
+  col('contract_json', 'TEXT'),
+  col('canonical_version', 'INTEGER'),
+  col('updated_at', 'TEXT', { notNull: true, default: fn("datetime('now')") }),
+  col('app_tag', 'TEXT'),
+  col('meta', 'TEXT', { notNull: true, default: lit('{}') }),
+  col('invariants', 'TEXT', { notNull: true, default: lit('[]') }),
+] as const;
+
+const ledgerColumns = [
+  col('id', 'INTEGER PRIMARY KEY AUTOINCREMENT'),
+  col('created_at', 'TEXT', {
+    notNull: true,
+    default: fn("strftime('%Y-%m-%dT%H:%M:%fZ','now')"),
+  }),
+  col('space', 'TEXT', { notNull: true }),
+  col('migration_name', 'TEXT', { notNull: true }),
+  col('migration_hash', 'TEXT', { notNull: true }),
+  col('origin_core_hash', 'TEXT'),
+  col('origin_profile_hash', 'TEXT'),
+  col('destination_core_hash', 'TEXT', { notNull: true }),
+  col('destination_profile_hash', 'TEXT'),
+  col('contract_json_before', 'TEXT'),
+  col('contract_json_after', 'TEXT'),
+  col('operations', 'TEXT', { notNull: true }),
+] as const;
+
+const markerTable = createTable({
+  table: '_prisma_marker',
+  ifNotExists: true,
+  columns: markerColumns,
+});
+
+const ledgerTable = createTable({
+  table: '_prisma_ledger',
+  ifNotExists: true,
+  columns: ledgerColumns,
+});
+
+export function buildSignMarkerBootstrapQueries(): readonly DdlNode[] {
+  return [markerTable];
+}
+
+export function buildControlTableBootstrapQueries(): readonly DdlNode[] {
+  return [markerTable, ledgerTable];
+}

package/src/contract-free/ddl.ts

@@ -0,0 +1,21 @@
+import type { DdlColumn } from '@prisma-next/sql-relational-core/ast';
+import { SqliteCreateTable } from '../core/ddl/nodes';
+
+/**
+ * Build a SQLite `CREATE TABLE` query node.
+ *
+ * Precondition: identifiers (`table`, column names/types) are emitted to SQL
+ * verbatim — they are not quoted or escaped, so callers must pass pre-trusted
+ * values (e.g. fixed control-plane identifiers). String-literal default values,
+ * by contrast, are single-quote-escaped (embedded `'` doubled) by the renderer.
+ * Identifier quoting for untrusted identifiers is added when the migration
+ * planner adopts this lowering path.
+ */
+export function createTable(options: {
+  readonly table: string;
+  readonly schema?: string;
+  readonly ifNotExists?: boolean;
+  readonly columns: readonly DdlColumn[];
+}): SqliteCreateTable {
+  return new SqliteCreateTable(options);
+}

package/src/core/ddl/nodes.ts

@@ -0,0 +1,41 @@
+import { type DdlColumn, DdlNode } 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]);
+}
+
+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>;
+
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+  }) {
+    super();
+    this.table = options.table;
+    this.schema = options.schema;
+    this.ifNotExists = options.ifNotExists;
+    this.columns = freezeDdlColumns(options.columns);
+    this.freeze();
+  }
+
+  override accept<R>(visitor: SqliteDdlVisitor<R>): R {
+    return visitor.createTable(this);
+  }
+}
+
+export type AnySqliteDdlNode = SqliteCreateTable;

package/src/core/descriptor-meta.ts

@@ -1,9 +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 = {
   ...sqliteTargetDescriptorMetaRuntime,
+  defaultNamespaceId: UNBOUND_NAMESPACE_ID,
   authoring: {
     field: sqliteAuthoringFieldPresets,
   },

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,
@@ -19,6 +19,7 @@ import type {
   MigrationRunnerResult,
 } from '@prisma-next/framework-components/control';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
@@ -28,8 +29,6 @@ import type { SqlitePlanTargetDetails } from './planner-target-details';
 import {
   buildLedgerInsertStatement,
   buildWriteMarkerStatements,
-  ensureLedgerTableStatement,
-  ensureMarkerTableStatement,
   MARKER_TABLE_NAME,
   readMarkerStatement,
   type SqlStatement,
@@ -70,7 +69,7 @@ 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);
 
@@ -127,7 +126,7 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
 
     if (!isSelfEdgeNoOp) {
       await this.upsertMarker(driver, options, existingMarker, space);
-      await this.recordLedgerEntry(driver, options, existingMarker, executedOperations);
+      await this.recordLedgerEntries(driver, options, existingMarker, executedOperations);
     }
 
     return runnerSuccess({
@@ -306,17 +305,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();
   }
 
@@ -623,25 +621,55 @@ class SqliteMigrationRunner implements SqlMigrationRunner<SqlitePlanTargetDetail
     await this.executeStatement(driver, statement);
   }
 
-  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 destinationProfileHash =
+      plan.destination.profileHash ??
+      options.destinationContract.profileHash ??
+      plan.destination.storageHash;
+    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;
+    const lastIndex = edges.length - 1;
+    for (const [i, edge] of edges.entries()) {
+      const edgeOps = executedOperations.slice(offset, offset + edge.operationCount);
+      offset += edge.operationCount;
+      const isFirst = i === 0;
+      const isLast = i === lastIndex;
+      await this.executeStatement(
+        driver,
+        buildLedgerInsertStatement({
+          space,
+          migrationName: edge.dirName,
+          migrationHash: edge.migrationHash,
+          originStorageHash: edge.from === '' ? null : edge.from,
+          originProfileHash:
+            isFirst && existingMarker?.storageHash === edge.from
+              ? (existingMarker.profileHash ?? null)
+              : null,
+          destinationStorageHash: edge.to,
+          destinationProfileHash:
+            isLast && edge.to === plan.destination.storageHash ? destinationProfileHash : null,
+          contractJsonBefore: isFirst ? (existingMarker?.contractJson ?? null) : null,
+          contractJsonAfter: isLast ? options.destinationContract : null,
+          operations: edgeOps,
+        }),
+      );
+    }
   }
 
   private async beginExclusiveTransaction(

package/src/core/migrations/statement-builders.ts

@@ -46,7 +46,10 @@ export const ensureMarkerTableStatement: SqlStatement = {
 export const ensureLedgerTableStatement: SqlStatement = {
   sql: `CREATE TABLE IF NOT EXISTS _prisma_ledger (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+    space TEXT NOT NULL,
+    migration_name TEXT NOT NULL,
+    migration_hash TEXT NOT NULL,
     origin_core_hash TEXT,
     origin_profile_hash TEXT,
     destination_core_hash TEXT NOT NULL,
@@ -167,6 +170,9 @@ export function buildWriteMarkerStatements(input: WriteMarkerInput): {
 }
 
 export interface LedgerInsertInput {
+  readonly space: string;
+  readonly migrationName: string;
+  readonly migrationHash: string;
   readonly originStorageHash?: string | null;
   readonly originProfileHash?: string | null;
   readonly destinationStorageHash: string;
@@ -179,6 +185,9 @@ export interface LedgerInsertInput {
 export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStatement {
   return {
     sql: `INSERT INTO _prisma_ledger (
+      space,
+      migration_name,
+      migration_hash,
       origin_core_hash,
       origin_profile_hash,
       destination_core_hash,
@@ -193,9 +202,15 @@ export function buildLedgerInsertStatement(input: LedgerInsertInput): SqlStateme
       ?,
       ?,
       ?,
+      ?,
+      ?,
+      ?,
       ?
     )`,
     params: [
+      input.space,
+      input.migrationName,
+      input.migrationHash,
       input.originStorageHash ?? null,
       input.originProfileHash ?? null,
       input.destinationStorageHash,

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

@@ -1,20 +1,49 @@
 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,
+  UNBOUND_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
+import type {
+  SqlNamespaceTablesInput,
+  SqlStorage,
+  StorageTable,
+} from '@prisma-next/sql-contract/types';
+import { SqliteDatabase, SqliteUnboundDatabase } 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 = super.hydrateSqlNamespaceEntry(nsId, raw) as {
+      id: string;
+      tables: Readonly<Record<string, StorageTable>>;
+    };
+    const { id, tables } = hydrated;
+    const emptyTables = Object.keys(tables).length === 0;
+    if (id === UNBOUND_NAMESPACE_ID && emptyTables) {
+      return SqliteUnboundDatabase.instance;
+    }
+    if (id !== UNBOUND_NAMESPACE_ID) {
+      throw new Error(
+        `SqliteContractSerializer: SQLite has no schema concept; the only valid namespace id is "${UNBOUND_NAMESPACE_ID}" (received "${id}").`,
+      );
+    }
+    return new SqliteDatabase({ id, tables });
+  }
 }