@prisma-next/target-sqlite 0.16.0-dev.32 → 0.16.0-dev.34

package/dist/{sqlite-contract-view-BKHdFV5Y.mjs.map → sqlite-contract-view-C9DFAHHV.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"sqlite-contract-view-BKHdFV5Y.mjs","names":[],"sources":["../src/core/sqlite-unbound-database.ts","../src/core/sqlite-contract-serializer.ts","../src/core/sqlite-contract-view.ts"],"sourcesContent":["import {\n  freezeNode,\n  hydrateNamespaceEntities,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { tableEntityKind } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  SqlNamespaceBase,\n  type SqlNamespaceEntries,\n  type SqlNamespaceInput,\n  type StorageTable,\n} from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { sqliteError } from './errors';\n\nexport type SqliteDatabaseInput = {\n  readonly id: string;\n  readonly entries: SqlNamespaceEntries;\n};\n\nconst SQLITE_NAMESPACE_KIND = 'sqlite-namespace' as const;\n\n/**\n * SQLite namespace concretion carrying table metadata under\n * `entries.table` and unqualified `qualifyTable()` emission for runtime\n * SQL rendering.\n */\nexport class SqliteDatabase extends SqlNamespaceBase {\n  declare readonly kind: string;\n\n  readonly id: string;\n  readonly entries: SqlNamespaceEntries;\n\n  constructor(input: SqliteDatabaseInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(\n      input.entries,\n      new Map([['table', tableEntityKind]]),\n      'carry',\n    );\n\n    this.entries = Object.freeze(\n      blindCast<\n        SqlNamespaceEntries,\n        \"SQLite's table-only descriptor map hydrates table→StorageTable and carries every other kind raw, so this open-dict result satisfies SqlNamespaceEntries; the descriptor Map erases the per-kind Node type from the return.\"\n      >(dispatched),\n    );\n    Object.defineProperty(this, 'kind', {\n      value: SQLITE_NAMESPACE_KIND,\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\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 SqliteDatabase {\n  static readonly instance: SqliteUnboundDatabase = new SqliteUnboundDatabase();\n\n  private constructor() {\n    super({ id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n}\n\n/**\n * The SQLite target's rejection of expression and partial indexes: the\n * family-shared authoring surfaces parse `expression:`/`where:` for every\n * SQL target, but SQLite neither renders nor introspects them (project\n * non-goal) — a contract carrying one must fail loudly at lowering instead\n * of silently producing an unverifiable index. Target-owned so no family\n * code branches on the target.\n */\nfunction rejectSqlBodyIndexes(input: SqlNamespaceInput): void {\n  const tables = input.entries['table'];\n  if (tables === undefined) return;\n  for (const [tableName, table] of Object.entries(tables)) {\n    const indexes = blindCast<\n      { readonly indexes?: readonly { name?: string; expression?: string; where?: string }[] },\n      'namespace table entries are StorageTable/StorageTableInput shapes; only the index list is read here'\n    >(table).indexes;\n    for (const index of indexes ?? []) {\n      if (index.expression !== undefined || index.where !== undefined) {\n        throw sqliteError(\n          'CONTRACT.ARGUMENT_INVALID',\n          `SQLite does not support expression or partial indexes: index \"${index.name ?? '<unnamed>'}\" on table \"${tableName}\" declares ${index.expression !== undefined ? 'an expression' : 'a where predicate'}. Use a fields-only index, or author this index against a Postgres target.`,\n        );\n      }\n    }\n  }\n}\n\nexport function buildSqliteNamespace(\n  input: SqlNamespaceInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  rejectSqlBodyIndexes(input);\n  if (input.id !== UNBOUND_NAMESPACE_ID) {\n    throw sqliteError(\n      'CONTRACT.NAMESPACE_INVALID',\n      `buildSqliteNamespace: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${input.id}\").`,\n      { meta: { received: input.id } },\n    );\n  }\n  const tableKind = input.entries['table'];\n  const tableCount = tableKind !== undefined ? Object.keys(tableKind).length : 0;\n  const hasUnknownKinds = Object.keys(input.entries).some((kind) => kind !== 'table');\n  if (tableCount === 0 && !hasUnknownKinds) {\n    return SqliteUnboundDatabase.instance;\n  }\n  return new SqliteDatabase({ id: input.id, entries: input.entries });\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 or a fresh\n * `SqliteDatabase` for the unbound slot with tables. The SQL family's\n * defensive validation in `defineContract` already rejects\n * user-declared SQLite namespaces, so this throw is a structural\n * safety net rather than a user-facing surface.\n */\nexport function sqliteCreateNamespace(\n  input: SqlNamespaceInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  return buildSqliteNamespace(input);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';\nimport type { Namespace } from '@prisma-next/framework-components/ir';\nimport type { SqlNamespaceInput, SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { buildSqliteNamespace } 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: Record<string, unknown>,\n  ): Namespace | SqlNamespaceInput {\n    const hydrated = blindCast<\n      SqlNamespaceInput,\n      'raw is always plain JSON, so super.hydrateSqlNamespaceEntry returns SqlNamespaceInput'\n    >(super.hydrateSqlNamespaceEntry(nsId, raw));\n    return buildSqliteNamespace(hydrated);\n  }\n\n  override serializeContract(contract: Contract<SqlStorage>): JsonObject {\n    const { storage, ...rest } = contract;\n    const namespacesJson: Record<string, JsonObject> = {};\n    for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n      namespacesJson[nsId] = {\n        id: ns.id,\n        entries: this.serializeNamespaceEntries(ns.entries),\n      };\n    }\n    return blindCast<\n      JsonObject,\n      'rest + storage are serialized plain values; spread preserves JSON-clean contract envelope'\n    >({\n      ...rest,\n      storage: {\n        storageHash: String(storage.storageHash),\n        namespaces: namespacesJson,\n        ...(storage.types !== undefined ? { types: this.serializeJsonObject(storage.types) } : {}),\n      },\n    });\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport {\n  buildSqlSingleNamespaceView,\n  type SqlSingleNamespaceView,\n} from '@prisma-next/sql-contract/contract-view';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SqliteContractSerializer } from './sqlite-contract-serializer';\n\n/**\n * A SQLite contract view: the deserialized contract intersected with by-name\n * accessors. It is substitutable for `Contract` (carries `storage`, `domain`,\n * …) and also exposes the single default namespace unwrapped with the SQL\n * built-in kinds promoted:\n *\n * ```ts\n * const view = SqliteContractView.fromJson<Contract>(contractJson);\n * view.table.users      // typed table leaf\n * view.entries.policy.X // pack-contributed kind (singular key)\n * view.storage          // the full contract is still present\n * ```\n *\n * SQLite has `sql.enums: false`, so it never emits `valueSet` entries; the\n * `valueSet` slot is therefore an empty map.\n */\nexport type SqliteContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> =\n  SqlSingleNamespaceView<TContract>;\n\nexport const SqliteContractView = {\n  /** Wrap an already-deserialized SQLite contract in a view. */\n  from<TContract extends Contract<SqlStorage>>(contract: TContract): SqliteContractView<TContract> {\n    return buildSqlSingleNamespaceView(contract);\n  },\n\n  /** Deserialize a SQLite contract JSON envelope and wrap it in a view. */\n  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>(\n    json: unknown,\n  ): SqliteContractView<TContract> {\n    const contract = new SqliteContractSerializer().deserializeContract<TContract>(json);\n    return buildSqlSingleNamespaceView(contract);\n  },\n};\n"],"mappings":"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"}
+{"version":3,"file":"sqlite-contract-view-C9DFAHHV.mjs","names":[],"sources":["../src/core/sqlite-unbound-database.ts","../src/core/sqlite-contract-serializer.ts","../src/core/sqlite-contract-view.ts"],"sourcesContent":["import {\n  freezeNode,\n  hydrateNamespaceEntities,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { tableEntityKind } from '@prisma-next/sql-contract/entity-kinds';\nimport {\n  SqlNamespaceBase,\n  type SqlNamespaceEntries,\n  type SqlNamespaceInput,\n  type StorageTable,\n} from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { sqliteError } from './errors';\n\nexport type SqliteDatabaseInput = {\n  readonly id: string;\n  readonly entries: SqlNamespaceEntries;\n};\n\nconst SQLITE_NAMESPACE_KIND = 'sqlite-namespace' as const;\n\n/**\n * SQLite namespace concretion carrying table metadata under\n * `entries.table` and unqualified `qualifyTable()` emission for runtime\n * SQL rendering.\n */\nexport class SqliteDatabase extends SqlNamespaceBase {\n  declare readonly kind: string;\n\n  readonly id: string;\n  readonly entries: SqlNamespaceEntries;\n\n  constructor(input: SqliteDatabaseInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(\n      input.entries,\n      new Map([['table', tableEntityKind]]),\n      'carry',\n    );\n\n    this.entries = Object.freeze(\n      blindCast<\n        SqlNamespaceEntries,\n        \"SQLite's table-only descriptor map hydrates table→StorageTable and carries every other kind raw, so this open-dict result satisfies SqlNamespaceEntries; the descriptor Map erases the per-kind Node type from the return.\"\n      >(dispatched),\n    );\n    Object.defineProperty(this, 'kind', {\n      value: SQLITE_NAMESPACE_KIND,\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\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 SqliteDatabase {\n  static readonly instance: SqliteUnboundDatabase = new SqliteUnboundDatabase();\n\n  private constructor() {\n    super({ id: UNBOUND_NAMESPACE_ID, entries: { table: {} } });\n  }\n}\n\n/**\n * The SQLite target's rejection of expression and partial indexes: the\n * family-shared authoring surfaces parse `expression:`/`where:` for every\n * SQL target, but SQLite neither renders nor introspects them (project\n * non-goal) — a contract carrying one must fail loudly at lowering instead\n * of silently producing an unverifiable index. Target-owned so no family\n * code branches on the target.\n */\nfunction rejectSqlBodyIndexes(input: SqlNamespaceInput): void {\n  const tables = input.entries['table'];\n  if (tables === undefined) return;\n  for (const [tableName, table] of Object.entries(tables)) {\n    const indexes = blindCast<\n      { readonly indexes?: readonly { name?: string; expression?: string; where?: string }[] },\n      'namespace table entries are StorageTable/StorageTableInput shapes; only the index list is read here'\n    >(table).indexes;\n    for (const index of indexes ?? []) {\n      if (index.expression !== undefined || index.where !== undefined) {\n        throw sqliteError(\n          'CONTRACT.ARGUMENT_INVALID',\n          `SQLite does not support expression or partial indexes: index \"${index.name ?? '<unnamed>'}\" on table \"${tableName}\" declares ${index.expression !== undefined ? 'an expression' : 'a where predicate'}. Use a fields-only index, or author this index against a Postgres target.`,\n        );\n      }\n    }\n  }\n}\n\nexport function buildSqliteNamespace(\n  input: SqlNamespaceInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  rejectSqlBodyIndexes(input);\n  if (input.id !== UNBOUND_NAMESPACE_ID) {\n    throw sqliteError(\n      'CONTRACT.NAMESPACE_INVALID',\n      `buildSqliteNamespace: SQLite has no schema concept; the only valid namespace id is \"${UNBOUND_NAMESPACE_ID}\" (received \"${input.id}\").`,\n      { meta: { received: input.id } },\n    );\n  }\n  const tableKind = input.entries['table'];\n  const tableCount = tableKind !== undefined ? Object.keys(tableKind).length : 0;\n  const hasUnknownKinds = Object.keys(input.entries).some((kind) => kind !== 'table');\n  if (tableCount === 0 && !hasUnknownKinds) {\n    return SqliteUnboundDatabase.instance;\n  }\n  return new SqliteDatabase({ id: input.id, entries: input.entries });\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 or a fresh\n * `SqliteDatabase` for the unbound slot with tables. The SQL family's\n * defensive validation in `defineContract` already rejects\n * user-declared SQLite namespaces, so this throw is a structural\n * safety net rather than a user-facing surface.\n */\nexport function sqliteCreateNamespace(\n  input: SqlNamespaceInput,\n): SqliteDatabase | SqliteUnboundDatabase {\n  return buildSqliteNamespace(input);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport { SqlContractSerializerBase } from '@prisma-next/family-sql/ir';\nimport type { Namespace } from '@prisma-next/framework-components/ir';\nimport type { SqlNamespaceInput, SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { buildSqliteNamespace } 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: Record<string, unknown>,\n  ): Namespace | SqlNamespaceInput {\n    const hydrated = blindCast<\n      SqlNamespaceInput,\n      'raw is always plain JSON, so super.hydrateSqlNamespaceEntry returns SqlNamespaceInput'\n    >(super.hydrateSqlNamespaceEntry(nsId, raw));\n    return buildSqliteNamespace(hydrated);\n  }\n\n  override serializeContract(contract: Contract<SqlStorage>): JsonObject {\n    const { storage, ...rest } = contract;\n    const namespacesJson: Record<string, JsonObject> = {};\n    for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n      namespacesJson[nsId] = {\n        id: ns.id,\n        entries: this.serializeNamespaceEntries(ns.entries),\n      };\n    }\n    return blindCast<\n      JsonObject,\n      'rest + storage are serialized plain values; spread preserves JSON-clean contract envelope'\n    >({\n      ...rest,\n      storage: {\n        storageHash: String(storage.storageHash),\n        namespaces: namespacesJson,\n        ...(storage.types !== undefined ? { types: this.serializeJsonObject(storage.types) } : {}),\n      },\n    });\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport {\n  buildSqlSingleNamespaceView,\n  type SqlSingleNamespaceView,\n} from '@prisma-next/sql-contract/contract-view';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { SqliteContractSerializer } from './sqlite-contract-serializer';\n\n/**\n * A SQLite contract view: the deserialized contract intersected with by-name\n * accessors. It is substitutable for `Contract` (carries `storage`, `domain`,\n * …) and also exposes the single default namespace unwrapped with the SQL\n * built-in kinds promoted:\n *\n * ```ts\n * const view = SqliteContractView.fromJson<Contract>(contractJson);\n * view.table.users      // typed table leaf\n * view.entries.policy.X // pack-contributed kind (singular key)\n * view.storage          // the full contract is still present\n * ```\n *\n * SQLite has `sql.enums: false`, so it never emits `valueSet` entries; the\n * `valueSet` slot is therefore an empty map.\n */\nexport type SqliteContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> =\n  SqlSingleNamespaceView<TContract>;\n\nexport const SqliteContractView = {\n  /** Wrap an already-deserialized SQLite contract in a view. */\n  from<TContract extends Contract<SqlStorage>>(contract: TContract): SqliteContractView<TContract> {\n    return buildSqlSingleNamespaceView(contract);\n  },\n\n  /** Deserialize a SQLite contract JSON envelope and wrap it in a view. */\n  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>(\n    json: unknown,\n  ): SqliteContractView<TContract> {\n    const contract = new SqliteContractSerializer().deserializeContract<TContract>(json);\n    return buildSqlSingleNamespaceView(contract);\n  },\n};\n"],"mappings":"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"}

package/dist/{sqlite-migration-DEqyJo40.mjs → sqlite-migration-BWnQUTne.mjs}

@@ -1,6 +1,6 @@
-import { t as errorSqliteMigrationStackMissing } from "./errors-B1JPoWDh.mjs";
-import { a as DropColumnCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall } from "./op-factory-call-BkqsWGiy.mjs";
-import { t as SqliteContractView } from "./sqlite-contract-view-BKHdFV5Y.mjs";
+import { t as errorSqliteMigrationStackMissing } from "./errors-By5PHAHj.mjs";
+import { a as DropColumnCall, l as RecreateTableCall, n as CreateIndexCall, o as DropIndexCall, r as CreateTableCall, s as DropTableCall, t as AddColumnCall } from "./op-factory-call-D0iJ2rLo.mjs";
+import { t as SqliteContractView } from "./sqlite-contract-view-C9DFAHHV.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { Migration } from "@prisma-next/family-sql/migration";
 import { MigrationContractViews } from "@prisma-next/migration-tools/migration";
@@ -91,4 +91,4 @@ var SqliteMigration = class extends Migration {
 //#endregion
 export { SqliteMigration as t };
 
-//# sourceMappingURL=sqlite-migration-DEqyJo40.mjs.map
+//# sourceMappingURL=sqlite-migration-BWnQUTne.mjs.map

package/dist/{sqlite-migration-DEqyJo40.mjs.map → sqlite-migration-BWnQUTne.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"sqlite-migration-DEqyJo40.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationClass,\n  SqlMigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { errorSqliteMigrationStackMissing } from '../errors';\nimport { SqliteContractView } from '../sqlite-contract-view';\nimport {\n  AddColumnCall,\n  CreateIndexCall,\n  CreateTableCall,\n  DropColumnCall,\n  DropIndexCall,\n  DropTableCall,\n  RecreateTableCall,\n} from './op-factory-call';\nimport type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\n/**\n * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`\n * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the\n * SQLite literal, so both user-authored migrations and renderer-generated\n * scaffolds can extend `SqliteMigration` directly without redeclaring\n * target-local identity.\n *\n * The constructor materializes a single SQLite `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected instance methods\n * forward to the corresponding `*Call` with that stored adapter, so user\n * migrations can write `this.createTable({...})` without threading the adapter\n * through every call.\n *\n * Binds the framework base's `Start` / `End` contract generics so a subclass\n * that assigns its snapshot-store `contract.json` imports to\n * `startContractJson` / `endContractJson` gets fully-typed view accessors:\n * `this.endContract` is a `SqliteContractView<End>`\n * (sole namespace unwrapped to the root — `this.endContract.table.<name>`),\n * built lazily from the JSON fields via the shared `MigrationContractViews`\n * helper. Mirrors `MongoMigration`'s view getters; the framework base derives\n * `describe()` from the same JSON.\n */\nexport abstract class SqliteMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<SqlitePlanTargetDetails, 'sqlite', Start, End> {\n  readonly targetId = 'sqlite' as const;\n\n  /**\n   * Materialized SQLite control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;\n\n  #endView = new MigrationContractViews<SqliteContractView<End>>(this, 'SqliteMigration', (json) =>\n    SqliteContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<SqliteContractView<Start>>(\n    this,\n    'SqliteMigration',\n    (json) => SqliteContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'sqlite'>) {\n    super(stack);\n    this.controlAdapter = stack?.adapter\n      ? blindCast<\n          SqlControlAdapter<'sqlite'>,\n          'The SQLite descriptor create() returns SqlControlAdapter<sqlite>; typed as wider ControlAdapterInstance at the framework boundary'\n        >(stack.adapter.create(stack))\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'sqlite'> {\n    if (!this.controlAdapter) {\n      throw errorSqliteMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed SQLite view over this migration's end-state contract — sole\n   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.\n   * Throws if no `endContractJson` was provided.\n   */\n  get endContract(): SqliteContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed SQLite view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): SqliteContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  protected createTable(options: {\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<Op> {\n    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(\n      this.controlAdapterFor('createTable'),\n    );\n  }\n\n  protected dropTable(options: { readonly table: string }): Promise<Op> {\n    return new DropTableCall(options.table).toOp(this.controlAdapterFor('dropTable'));\n  }\n\n  protected addColumn(options: {\n    readonly table: string;\n    readonly column: SqliteColumnSpec;\n  }): Promise<Op> {\n    return new AddColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {\n    return new DropColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected createIndex(options: {\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n  }): Promise<Op> {\n    return new CreateIndexCall(options.table, options.index, options.columns).toOp(\n      this.controlAdapterFor('createIndex'),\n    );\n  }\n\n  protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {\n    return new DropIndexCall(options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected recreateTable(options: {\n    readonly tableName: string;\n    readonly contractTable: SqliteTableSpec;\n    readonly schemaColumnNames: readonly string[];\n    readonly indexes: readonly SqliteIndexSpec[];\n    readonly summary: string;\n    readonly postchecks: readonly { readonly description: string; readonly sql: string }[];\n    readonly operationClass: MigrationOperationClass;\n  }): Promise<Op> {\n    return new RecreateTableCall(options).toOp(this.controlAdapterFor('recreateTable'));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,IAAsB,kBAAtB,cAGUA,UAA4D;CACpE,WAAoB;;;;;;;CAQpB;CAEA,WAAW,IAAI,uBAAgD,MAAM,oBAAoB,SACvF,mBAAmB,SAAc,IAAI,CACvC;CACA,aAAa,IAAI,uBACf,MACA,oBACC,SAAS,mBAAmB,SAAgB,IAAI,CACnD;CAEA,YAAY,OAAuC;EACjD,MAAM,KAAK;EACX,KAAK,iBAAiB,OAAO,UACzB,UAGE,MAAM,QAAQ,OAAO,KAAK,CAAC,IAC7B,KAAA;CACN;;;;;;CAOA,kBAA0B,WAAgD;EACxE,IAAI,CAAC,KAAK,gBACR,MAAM,iCAAiC,SAAS;EAElD,OAAO,KAAK;CACd;;;;;;CAOA,IAAI,cAAuC;EACzC,OAAO,KAAKC,SAAS;CACvB;;;;;CAMA,IAAI,gBAAkD;EACpD,OAAO,KAAKC,WAAW;CACzB;CAEA,YAAsB,SAKN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,SAAS,QAAQ,WAAW,CAAC,CAAC,KAC9E,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAAkD;EACpE,OAAO,IAAI,cAAc,QAAQ,KAAK,CAAC,CAAC,KAAK,KAAK,kBAAkB,WAAW,CAAC;CAClF;CAEA,UAAoB,SAGJ;EACd,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACtD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,WAAqB,SAA2E;EAC9F,OAAO,IAAI,eAAe,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACvD,KAAK,kBAAkB,YAAY,CACrC;CACF;CAEA,YAAsB,SAIN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,OAAO,QAAQ,OAAO,CAAC,CAAC,KACxE,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAA0E;EAC5F,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,KAAK,CAAC,CAAC,KACrD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,cAAwB,SAQR;EACd,OAAO,IAAI,kBAAkB,OAAO,CAAC,CAAC,KAAK,KAAK,kBAAkB,eAAe,CAAC;CACpF;AACF"}
+{"version":3,"file":"sqlite-migration-BWnQUTne.mjs","names":["SqlMigration","#endView","#startView"],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type {\n  MigrationOperationClass,\n  SqlMigrationPlanOperation,\n} from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { MigrationContractViews } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { errorSqliteMigrationStackMissing } from '../errors';\nimport { SqliteContractView } from '../sqlite-contract-view';\nimport {\n  AddColumnCall,\n  CreateIndexCall,\n  CreateTableCall,\n  DropColumnCall,\n  DropIndexCall,\n  DropTableCall,\n  RecreateTableCall,\n} from './op-factory-call';\nimport type { SqliteColumnSpec, SqliteIndexSpec, SqliteTableSpec } from './operations/shared';\nimport type { SqlitePlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<SqlitePlanTargetDetails>;\n\n/**\n * Target-owned base class for SQLite migrations. Fixes the `SqlMigration`\n * generic to `SqlitePlanTargetDetails` and the abstract `targetId` to the\n * SQLite literal, so both user-authored migrations and renderer-generated\n * scaffolds can extend `SqliteMigration` directly without redeclaring\n * target-local identity.\n *\n * The constructor materializes a single SQLite `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected instance methods\n * forward to the corresponding `*Call` with that stored adapter, so user\n * migrations can write `this.createTable({...})` without threading the adapter\n * through every call.\n *\n * Binds the framework base's `Start` / `End` contract generics so a subclass\n * that assigns its snapshot-store `contract.json` imports to\n * `startContractJson` / `endContractJson` gets fully-typed view accessors:\n * `this.endContract` is a `SqliteContractView<End>`\n * (sole namespace unwrapped to the root — `this.endContract.table.<name>`),\n * built lazily from the JSON fields via the shared `MigrationContractViews`\n * helper. Mirrors `MongoMigration`'s view getters; the framework base derives\n * `describe()` from the same JSON.\n */\nexport abstract class SqliteMigration<\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends SqlMigration<SqlitePlanTargetDetails, 'sqlite', Start, End> {\n  readonly targetId = 'sqlite' as const;\n\n  /**\n   * Materialized SQLite control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `controlAdapterFor`\n   * throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'sqlite'> | undefined;\n\n  #endView = new MigrationContractViews<SqliteContractView<End>>(this, 'SqliteMigration', (json) =>\n    SqliteContractView.fromJson<End>(json),\n  );\n  #startView = new MigrationContractViews<SqliteContractView<Start>>(\n    this,\n    'SqliteMigration',\n    (json) => SqliteContractView.fromJson<Start>(json),\n  );\n\n  constructor(stack?: ControlStack<'sql', 'sqlite'>) {\n    super(stack);\n    this.controlAdapter = stack?.adapter\n      ? blindCast<\n          SqlControlAdapter<'sqlite'>,\n          'The SQLite descriptor create() returns SqlControlAdapter<sqlite>; typed as wider ControlAdapterInstance at the framework boundary'\n        >(stack.adapter.create(stack))\n      : undefined;\n  }\n\n  /**\n   * Returns the materialized control adapter, or throws a MIGRATION.SQLITE_CONTROL_STACK_MISSING naming\n   * `operation` when the migration was constructed without a `ControlStack`.\n   * Single home for the null-check that every DDL/DML method shares.\n   */\n  private controlAdapterFor(operation: string): SqlControlAdapter<'sqlite'> {\n    if (!this.controlAdapter) {\n      throw errorSqliteMigrationStackMissing(operation);\n    }\n    return this.controlAdapter;\n  }\n\n  /**\n   * The typed SQLite view over this migration's end-state contract — sole\n   * namespace unwrapped to the root, so `this.endContract.table.<name>` etc.\n   * Throws if no `endContractJson` was provided.\n   */\n  get endContract(): SqliteContractView<End> {\n    return this.#endView.endContract;\n  }\n\n  /**\n   * The typed SQLite view over this migration's start-state contract, or\n   * `null` for a baseline migration (no `startContractJson`).\n   */\n  get startContract(): SqliteContractView<Start> | null {\n    return this.#startView.startContract;\n  }\n\n  protected createTable(options: {\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): Promise<Op> {\n    return new CreateTableCall(options.table, options.columns, options.constraints).toOp(\n      this.controlAdapterFor('createTable'),\n    );\n  }\n\n  protected dropTable(options: { readonly table: string }): Promise<Op> {\n    return new DropTableCall(options.table).toOp(this.controlAdapterFor('dropTable'));\n  }\n\n  protected addColumn(options: {\n    readonly table: string;\n    readonly column: SqliteColumnSpec;\n  }): Promise<Op> {\n    return new AddColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('addColumn'),\n    );\n  }\n\n  protected dropColumn(options: { readonly table: string; readonly column: string }): Promise<Op> {\n    return new DropColumnCall(options.table, options.column).toOp(\n      this.controlAdapterFor('dropColumn'),\n    );\n  }\n\n  protected createIndex(options: {\n    readonly table: string;\n    readonly index: string;\n    readonly columns: readonly string[];\n  }): Promise<Op> {\n    return new CreateIndexCall(options.table, options.index, options.columns).toOp(\n      this.controlAdapterFor('createIndex'),\n    );\n  }\n\n  protected dropIndex(options: { readonly table: string; readonly index: string }): Promise<Op> {\n    return new DropIndexCall(options.table, options.index).toOp(\n      this.controlAdapterFor('dropIndex'),\n    );\n  }\n\n  protected recreateTable(options: {\n    readonly tableName: string;\n    readonly contractTable: SqliteTableSpec;\n    readonly schemaColumnNames: readonly string[];\n    readonly indexes: readonly SqliteIndexSpec[];\n    readonly summary: string;\n    readonly postchecks: readonly { readonly description: string; readonly sql: string }[];\n    readonly operationClass: MigrationOperationClass;\n  }): Promise<Op> {\n    return new RecreateTableCall(options).toOp(this.controlAdapterFor('recreateTable'));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,IAAsB,kBAAtB,cAGUA,UAA4D;CACpE,WAAoB;;;;;;;CAQpB;CAEA,WAAW,IAAI,uBAAgD,MAAM,oBAAoB,SACvF,mBAAmB,SAAc,IAAI,CACvC;CACA,aAAa,IAAI,uBACf,MACA,oBACC,SAAS,mBAAmB,SAAgB,IAAI,CACnD;CAEA,YAAY,OAAuC;EACjD,MAAM,KAAK;EACX,KAAK,iBAAiB,OAAO,UACzB,UAGE,MAAM,QAAQ,OAAO,KAAK,CAAC,IAC7B,KAAA;CACN;;;;;;CAOA,kBAA0B,WAAgD;EACxE,IAAI,CAAC,KAAK,gBACR,MAAM,iCAAiC,SAAS;EAElD,OAAO,KAAK;CACd;;;;;;CAOA,IAAI,cAAuC;EACzC,OAAO,KAAKC,SAAS;CACvB;;;;;CAMA,IAAI,gBAAkD;EACpD,OAAO,KAAKC,WAAW;CACzB;CAEA,YAAsB,SAKN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,SAAS,QAAQ,WAAW,CAAC,CAAC,KAC9E,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAAkD;EACpE,OAAO,IAAI,cAAc,QAAQ,KAAK,CAAC,CAAC,KAAK,KAAK,kBAAkB,WAAW,CAAC;CAClF;CAEA,UAAoB,SAGJ;EACd,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACtD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,WAAqB,SAA2E;EAC9F,OAAO,IAAI,eAAe,QAAQ,OAAO,QAAQ,MAAM,CAAC,CAAC,KACvD,KAAK,kBAAkB,YAAY,CACrC;CACF;CAEA,YAAsB,SAIN;EACd,OAAO,IAAI,gBAAgB,QAAQ,OAAO,QAAQ,OAAO,QAAQ,OAAO,CAAC,CAAC,KACxE,KAAK,kBAAkB,aAAa,CACtC;CACF;CAEA,UAAoB,SAA0E;EAC5F,OAAO,IAAI,cAAc,QAAQ,OAAO,QAAQ,KAAK,CAAC,CAAC,KACrD,KAAK,kBAAkB,WAAW,CACpC;CACF;CAEA,cAAwB,SAQR;EACd,OAAO,IAAI,kBAAkB,OAAO,CAAC,CAAC,KAAK,KAAK,kBAAkB,eAAe,CAAC;CACpF;AACF"}

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.16.0-dev.32",
+  "version": "0.16.0-dev.34",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.16.0-dev.32",
-    "@prisma-next/contract": "0.16.0-dev.32",
-    "@prisma-next/errors": "0.16.0-dev.32",
-    "@prisma-next/family-sql": "0.16.0-dev.32",
-    "@prisma-next/framework-components": "0.16.0-dev.32",
-    "@prisma-next/migration-tools": "0.16.0-dev.32",
-    "@prisma-next/sql-contract": "0.16.0-dev.32",
-    "@prisma-next/sql-errors": "0.16.0-dev.32",
-    "@prisma-next/sql-relational-core": "0.16.0-dev.32",
-    "@prisma-next/sql-runtime": "0.16.0-dev.32",
-    "@prisma-next/sql-schema-ir": "0.16.0-dev.32",
-    "@prisma-next/ts-render": "0.16.0-dev.32",
-    "@prisma-next/utils": "0.16.0-dev.32",
+    "@prisma-next/cli": "0.16.0-dev.34",
+    "@prisma-next/contract": "0.16.0-dev.34",
+    "@prisma-next/errors": "0.16.0-dev.34",
+    "@prisma-next/family-sql": "0.16.0-dev.34",
+    "@prisma-next/framework-components": "0.16.0-dev.34",
+    "@prisma-next/migration-tools": "0.16.0-dev.34",
+    "@prisma-next/sql-contract": "0.16.0-dev.34",
+    "@prisma-next/sql-errors": "0.16.0-dev.34",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.34",
+    "@prisma-next/sql-runtime": "0.16.0-dev.34",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.34",
+    "@prisma-next/ts-render": "0.16.0-dev.34",
+    "@prisma-next/utils": "0.16.0-dev.34",
     "@standard-schema/spec": "1.1.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-sqlite": "0.16.0-dev.32",
-    "@prisma-next/test-utils": "0.16.0-dev.32",
-    "@prisma-next/tsconfig": "0.16.0-dev.32",
-    "@prisma-next/tsdown": "0.16.0-dev.32",
+    "@prisma-next/driver-sqlite": "0.16.0-dev.34",
+    "@prisma-next/test-utils": "0.16.0-dev.34",
+    "@prisma-next/tsconfig": "0.16.0-dev.34",
+    "@prisma-next/tsdown": "0.16.0-dev.34",
     "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
@@ -42,6 +42,7 @@
     "src"
   ],
   "exports": {
+    "./codec-descriptor": "./dist/codec-descriptor.mjs",
     "./codec-ids": "./dist/codec-ids.mjs",
     "./codec-types": "./dist/codec-types.mjs",
     "./codecs": "./dist/codecs.mjs",

package/src/core/codec-descriptor.ts

@@ -0,0 +1,253 @@
+import type { JsonValue } from '@prisma-next/contract/types';
+import {
+  type AnyCodecDescriptor,
+  type Codec,
+  type CodecDescriptor,
+  CodecDescriptorImpl,
+  type CodecInstanceContext,
+  type CodecMeta,
+  type CodecRef,
+  type CodecTrait,
+  validateCodecTypeParams,
+} from '@prisma-next/framework-components/codec';
+import type { ProjectionExpr } from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
+import { structuredError } from '@prisma-next/utils/structured-error';
+
+const SQLITE_CODEC_DESCRIPTOR_KIND = 'sqlite-codec' as const;
+
+export interface AnySqliteCodecDescriptor extends AnyCodecDescriptor {
+  readonly descriptorKind: typeof SQLITE_CODEC_DESCRIPTOR_KIND;
+  projectJson(expression: ProjectionExpr, ref: CodecRef): ProjectionExpr;
+}
+
+export abstract class SqliteCodecDescriptor<P = void>
+  extends CodecDescriptorImpl<P>
+  implements AnySqliteCodecDescriptor
+{
+  readonly descriptorKind = SQLITE_CODEC_DESCRIPTOR_KIND;
+
+  protected abstract jsonProjection(expression: ProjectionExpr, params: P): ProjectionExpr;
+
+  projectJson(expression: ProjectionExpr, ref: CodecRef): ProjectionExpr {
+    if (ref.many === true) {
+      throw structuredError(
+        'SQLITE.CODEC_DESCRIPTOR_ARRAY_UNSUPPORTED',
+        `Codec '${ref.codecId}' uses CodecRef.many, but SQLite codec descriptors do not support stored scalar arrays.`,
+        {
+          why: 'SQLite has no stored scalar-array codec protocol, so applying a scalar projection to the whole stored array would be ambiguous.',
+          fix: 'Use a scalar CodecRef or introduce an explicit target representation before projecting stored arrays.',
+          meta: { codecId: ref.codecId },
+        },
+      );
+    }
+
+    return this.jsonProjection(expression, this.validateParams(ref));
+  }
+
+  private validateParams(ref: CodecRef): P {
+    return blindCast<
+      P,
+      'validateCodecTypeParams synchronously validates this descriptor schema before the typed hook'
+    >(validateCodecTypeParams(this, ref));
+  }
+}
+
+type DescriptorParams<D extends AnyCodecDescriptor> =
+  D extends CodecDescriptor<infer P> ? P : never;
+
+export interface SqliteCodecOptions<P> {
+  readonly jsonProjection: (expression: ProjectionExpr, params: P) => ProjectionExpr;
+}
+
+export type AdaptedSqliteCodecDescriptor<D extends AnyCodecDescriptor> = Pick<
+  D,
+  keyof CodecDescriptor<DescriptorParams<D>>
+> &
+  Pick<AnySqliteCodecDescriptor, 'descriptorKind' | 'projectJson'>;
+
+class SqliteCodecDescriptorAdapter<D extends AnyCodecDescriptor> extends SqliteCodecDescriptor<
+  DescriptorParams<D>
+> {
+  override readonly codecId: string;
+  override readonly traits: readonly CodecTrait[];
+  override readonly targetTypes: readonly string[];
+  override readonly paramsSchema: D['paramsSchema'];
+  override readonly metaFor?: (params: DescriptorParams<D>) => CodecMeta | undefined;
+  override readonly renderOutputType?: (params: DescriptorParams<D>) => string | undefined;
+  override readonly renderInputType?: (params: DescriptorParams<D>) => string | undefined;
+  override readonly renderValueLiteral?: (
+    value: JsonValue,
+    side: 'output' | 'input',
+  ) => string | undefined;
+
+  constructor(
+    private readonly descriptor: D,
+    private readonly options: SqliteCodecOptions<DescriptorParams<D>>,
+  ) {
+    super();
+    this.codecId = descriptor.codecId;
+    this.traits = descriptor.traits;
+    this.targetTypes = descriptor.targetTypes;
+    this.paramsSchema = descriptor.paramsSchema;
+
+    if (descriptor.meta !== undefined) {
+      Object.defineProperty(this, 'meta', {
+        value: descriptor.meta,
+        enumerable: true,
+      });
+    }
+
+    const metaFor = descriptor.metaFor;
+    if (metaFor !== undefined) {
+      this.metaFor = (params) => metaFor.call(descriptor, params);
+    }
+
+    const renderOutputType = descriptor.renderOutputType;
+    if (renderOutputType !== undefined) {
+      this.renderOutputType = (params) => renderOutputType.call(descriptor, params);
+    }
+
+    const renderInputType = descriptor.renderInputType;
+    if (renderInputType !== undefined) {
+      this.renderInputType = (params) => renderInputType.call(descriptor, params);
+    }
+
+    const renderValueLiteral = descriptor.renderValueLiteral;
+    if (renderValueLiteral !== undefined) {
+      this.renderValueLiteral = (value, side) => renderValueLiteral.call(descriptor, value, side);
+    }
+  }
+
+  override get isParameterized(): boolean {
+    return this.descriptor.isParameterized;
+  }
+
+  override readonly factory = (
+    params: DescriptorParams<D>,
+  ): ((ctx: CodecInstanceContext) => Codec<string, readonly CodecTrait[], unknown, unknown>) =>
+    this.descriptor.factory(params);
+
+  protected override jsonProjection(
+    expression: ProjectionExpr,
+    params: DescriptorParams<D>,
+  ): ProjectionExpr {
+    return this.options.jsonProjection(expression, params);
+  }
+}
+
+export function sqliteCodec<D extends AnyCodecDescriptor>(
+  descriptor: D,
+  options: SqliteCodecOptions<DescriptorParams<D>>,
+): AdaptedSqliteCodecDescriptor<D> {
+  return blindCast<
+    AdaptedSqliteCodecDescriptor<D>,
+    'the adapter delegates every ordinary descriptor member while adding the validated SQLite protocol'
+  >(new SqliteCodecDescriptorAdapter(descriptor, options));
+}
+
+export function defineSqliteCodecs<const Descriptors extends readonly AnySqliteCodecDescriptor[]>(
+  descriptors: Descriptors,
+): Descriptors {
+  return descriptors;
+}
+
+export function isSqliteCodecDescriptor(value: unknown): value is AnySqliteCodecDescriptor {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'descriptorKind' in value &&
+    value.descriptorKind === SQLITE_CODEC_DESCRIPTOR_KIND &&
+    'codecId' in value &&
+    typeof value.codecId === 'string' &&
+    'traits' in value &&
+    Array.isArray(value.traits) &&
+    'targetTypes' in value &&
+    Array.isArray(value.targetTypes) &&
+    value.targetTypes.every((targetType) => typeof targetType === 'string') &&
+    'paramsSchema' in value &&
+    isObjectLike(value.paramsSchema) &&
+    '~standard' in value.paramsSchema &&
+    isObjectLike(value.paramsSchema['~standard']) &&
+    'validate' in value.paramsSchema['~standard'] &&
+    typeof value.paramsSchema['~standard'].validate === 'function' &&
+    'isParameterized' in value &&
+    typeof value.isParameterized === 'boolean' &&
+    'factory' in value &&
+    typeof value.factory === 'function' &&
+    'projectJson' in value &&
+    typeof value.projectJson === 'function'
+  );
+}
+
+function isObjectLike(value: unknown): value is object {
+  return (typeof value === 'object' && value !== null) || typeof value === 'function';
+}
+
+export interface SqliteCodecDescriptorRegistry {
+  descriptorFor(codecId: string): AnySqliteCodecDescriptor | undefined;
+  values(): IterableIterator<AnySqliteCodecDescriptor>;
+}
+
+class SqliteCodecDescriptorRegistryImpl implements SqliteCodecDescriptorRegistry {
+  readonly #descriptors: ReadonlyMap<string, AnySqliteCodecDescriptor>;
+
+  constructor(descriptors: ReadonlyMap<string, AnySqliteCodecDescriptor>) {
+    this.#descriptors = descriptors;
+    Object.freeze(this);
+  }
+
+  descriptorFor(codecId: string): AnySqliteCodecDescriptor | undefined {
+    return this.#descriptors.get(codecId);
+  }
+
+  *values(): IterableIterator<AnySqliteCodecDescriptor> {
+    yield* this.#descriptors.values();
+  }
+}
+
+export function buildSqliteCodecDescriptorRegistry(
+  descriptors: ReadonlyArray<unknown>,
+): SqliteCodecDescriptorRegistry {
+  const byId = new Map<string, AnySqliteCodecDescriptor>();
+
+  for (const descriptor of descriptors) {
+    if (!isSqliteCodecDescriptor(descriptor)) {
+      const codecId = candidateCodecId(descriptor);
+      throw structuredError(
+        'SQLITE.CODEC_DESCRIPTOR_INVALID',
+        `Codec descriptor '${codecId}' is not a valid SQLite codec descriptor.`,
+        {
+          why: 'SQLite codec registries require the sqlite-codec discriminant and complete target descriptor methods.',
+          fix: 'Extend SqliteCodecDescriptor or adapt a generic descriptor with sqliteCodec().',
+          meta: { codecId },
+        },
+      );
+    }
+
+    if (byId.has(descriptor.codecId)) {
+      throw structuredError(
+        'SQLITE.CODEC_DESCRIPTOR_DUPLICATE',
+        `Duplicate SQLite codec descriptor id '${descriptor.codecId}'.`,
+        {
+          why: 'Each codecId must resolve to exactly one SQLite descriptor during registry composition.',
+          fix: 'Remove the duplicate target, adapter, or extension contribution.',
+          meta: { codecId: descriptor.codecId },
+        },
+      );
+    }
+
+    byId.set(descriptor.codecId, descriptor);
+  }
+
+  return new SqliteCodecDescriptorRegistryImpl(byId);
+}
+
+function candidateCodecId(value: unknown): string {
+  return typeof value === 'object' &&
+    value !== null &&
+    'codecId' in value &&
+    typeof value.codecId === 'string'
+    ? value.codecId
+    : '<unknown>';
+}

package/src/core/codecs.ts

@@ -3,7 +3,7 @@
  *
  * Each codec ships as three artifacts:
  *
- * 1. A `SqliteXCodec` class extending {@link CodecImpl} that wraps the encode/decode/encodeJson/decodeJson conversions inline. SQLite's runtime conversions are simple enough that there is no shared helper module; the class bodies are the single source of truth. 2. A `SqliteXDescriptor` class extending {@link CodecDescriptorImpl} declaring the codec id, traits, target types, and params schema. SQLite codecs do not carry
+ * 1. A `SqliteXCodec` class extending {@link CodecImpl} that wraps the encode/decode/encodeJson/decodeJson conversions inline. SQLite's runtime conversions are simple enough that there is no shared helper module; the class bodies are the single source of truth. 2. A `SqliteXDescriptor` class extending {@link SqliteCodecDescriptor} declaring the codec id, traits, target types, params schema, and current scalar JSON projection. SQLite codecs do not carry
  * `meta` (no per-target native-type meta today) and are all non-parameterized. 3. A per-codec column helper (`sqliteXColumn`) that calls `descriptor.factory()` directly and packages the result into a {@link ColumnSpec} via the framework {@link column} packager. The helper is tied to its descriptor with `satisfies ColumnHelperFor` + `ColumnHelperForStrict` (every SQLite codec's resolved type is well-defined).
  *
  * After TML-2357 this is the canonical source of SQLite codec metadata and runtime behaviour — the legacy `mkCodec` / `defineCodec` carriers (and the parallel `byScalar` / `codecDescriptorDefinitions` collection exports) retired with the deletion sweep.
@@ -13,9 +13,7 @@
 
 import type { JsonValue } from '@prisma-next/contract/types';
 import {
-  type AnyCodecDescriptor,
   type CodecCallContext,
-  CodecDescriptorImpl,
   CodecImpl,
   type CodecInstanceContext,
   type ColumnHelperFor,
@@ -24,11 +22,13 @@ import {
   voidParamsSchema,
 } from '@prisma-next/framework-components/codec';
 import {
+  type ProjectionExpr,
   sqlCharDescriptor,
   sqlFloatDescriptor,
   sqlIntDescriptor,
   sqlVarcharDescriptor,
 } from '@prisma-next/sql-relational-core/ast';
+import { defineSqliteCodecs, SqliteCodecDescriptor, sqliteCodec } from './codec-descriptor';
 import {
   SQLITE_BIGINT_CODEC_ID,
   SQLITE_BLOB_CODEC_ID,
@@ -40,6 +40,24 @@ import {
 } from './codec-ids';
 import { sqliteError } from './errors';
 
+const identityJsonProjection = (expression: ProjectionExpr): ProjectionExpr => expression;
+
+export const sqliteSqlCharDescriptor = sqliteCodec(sqlCharDescriptor, {
+  jsonProjection: identityJsonProjection,
+});
+
+export const sqliteSqlVarcharDescriptor = sqliteCodec(sqlVarcharDescriptor, {
+  jsonProjection: identityJsonProjection,
+});
+
+export const sqliteSqlIntDescriptor = sqliteCodec(sqlIntDescriptor, {
+  jsonProjection: identityJsonProjection,
+});
+
+export const sqliteSqlFloatDescriptor = sqliteCodec(sqlFloatDescriptor, {
+  jsonProjection: identityJsonProjection,
+});
+
 export class SqliteTextCodec extends CodecImpl<
   typeof SQLITE_TEXT_CODEC_ID,
   readonly ['equality', 'order', 'textual'],
@@ -60,7 +78,10 @@ export class SqliteTextCodec extends CodecImpl<
   }
 }
 
-export class SqliteTextDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteTextDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_TEXT_CODEC_ID;
   override readonly traits = ['equality', 'order', 'textual'] as const;
   override readonly targetTypes = ['text'] as const;
@@ -98,7 +119,10 @@ export class SqliteIntegerCodec extends CodecImpl<
   }
 }
 
-export class SqliteIntegerDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteIntegerDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_INTEGER_CODEC_ID;
   override readonly traits = ['equality', 'order', 'numeric'] as const;
   override readonly targetTypes = ['integer'] as const;
@@ -136,7 +160,10 @@ export class SqliteRealCodec extends CodecImpl<
   }
 }
 
-export class SqliteRealDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteRealDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_REAL_CODEC_ID;
   override readonly traits = ['equality', 'order', 'numeric'] as const;
   override readonly targetTypes = ['real'] as const;
@@ -183,7 +210,10 @@ export class SqliteBlobCodec extends CodecImpl<
   }
 }
 
-export class SqliteBlobDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteBlobDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_BLOB_CODEC_ID;
   override readonly traits = ['equality'] as const;
   override readonly targetTypes = ['blob'] as const;
@@ -240,7 +270,10 @@ export class SqliteDatetimeCodec extends CodecImpl<
   }
 }
 
-export class SqliteDatetimeDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteDatetimeDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_DATETIME_CODEC_ID;
   override readonly traits = ['equality', 'order'] as const;
   override readonly targetTypes = ['text'] as const;
@@ -278,7 +311,10 @@ export class SqliteJsonCodec extends CodecImpl<
   }
 }
 
-export class SqliteJsonDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteJsonDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_JSON_CODEC_ID;
   override readonly traits = ['equality'] as const;
   override readonly targetTypes = ['text'] as const;
@@ -338,7 +374,10 @@ export class SqliteBigintCodec extends CodecImpl<
   }
 }
 
-export class SqliteBigintDescriptor extends CodecDescriptorImpl<void> {
+export class SqliteBigintDescriptor extends SqliteCodecDescriptor<void> {
+  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {
+    return expression;
+  }
   override readonly codecId = SQLITE_BIGINT_CODEC_ID;
   override readonly traits = ['equality', 'order', 'numeric'] as const;
   override readonly targetTypes = ['integer'] as const;
@@ -356,11 +395,11 @@ export const sqliteBigintColumn = () =>
 sqliteBigintColumn satisfies ColumnHelperFor<SqliteBigintDescriptor>;
 sqliteBigintColumn satisfies ColumnHelperForStrict<SqliteBigintDescriptor>;
 
-export const codecDescriptors: readonly AnyCodecDescriptor[] = [
-  sqlCharDescriptor,
-  sqlVarcharDescriptor,
-  sqlIntDescriptor,
-  sqlFloatDescriptor,
+export const codecDescriptors = defineSqliteCodecs([
+  sqliteSqlCharDescriptor,
+  sqliteSqlVarcharDescriptor,
+  sqliteSqlIntDescriptor,
+  sqliteSqlFloatDescriptor,
   sqliteTextDescriptor,
   sqliteIntegerDescriptor,
   sqliteRealDescriptor,
@@ -368,4 +407,4 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   sqliteDatetimeDescriptor,
   sqliteJsonDescriptor,
   sqliteBigintDescriptor,
-];
+]);

package/src/core/registry.ts

@@ -1,5 +1,6 @@
 import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
 import type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { buildSqliteCodecDescriptorRegistry } from './codec-descriptor';
 import { codecDescriptors } from './codecs';
 
 /**
@@ -9,3 +10,5 @@ import { codecDescriptors } from './codecs';
  */
 export const sqliteCodecRegistry: CodecDescriptorRegistry =
   buildCodecDescriptorRegistry(codecDescriptors);
+
+export const sqliteCodecDescriptorRegistry = buildSqliteCodecDescriptorRegistry(codecDescriptors);

package/src/exports/codec-descriptor.ts

@@ -0,0 +1,11 @@
+export {
+  type AdaptedSqliteCodecDescriptor,
+  type AnySqliteCodecDescriptor,
+  buildSqliteCodecDescriptorRegistry,
+  defineSqliteCodecs,
+  isSqliteCodecDescriptor,
+  SqliteCodecDescriptor,
+  type SqliteCodecDescriptorRegistry,
+  type SqliteCodecOptions,
+  sqliteCodec,
+} from '../core/codec-descriptor';

package/src/exports/codec-types.ts

@@ -5,12 +5,6 @@
  */
 
 import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
-import {
-  sqlCharDescriptor,
-  sqlFloatDescriptor,
-  sqlIntDescriptor,
-  sqlVarcharDescriptor,
-} from '@prisma-next/sql-relational-core/ast';
 import type { JsonValue } from '../core/codec-helpers';
 import {
   sqliteBigintDescriptor,
@@ -19,14 +13,18 @@ import {
   sqliteIntegerDescriptor,
   sqliteJsonDescriptor,
   sqliteRealDescriptor,
+  sqliteSqlCharDescriptor,
+  sqliteSqlFloatDescriptor,
+  sqliteSqlIntDescriptor,
+  sqliteSqlVarcharDescriptor,
   sqliteTextDescriptor,
 } from '../core/codecs';
 
 const codecDescriptorMap = {
-  char: sqlCharDescriptor,
-  varchar: sqlVarcharDescriptor,
-  int: sqlIntDescriptor,
-  float: sqlFloatDescriptor,
+  char: sqliteSqlCharDescriptor,
+  varchar: sqliteSqlVarcharDescriptor,
+  int: sqliteSqlIntDescriptor,
+  float: sqliteSqlFloatDescriptor,
   text: sqliteTextDescriptor,
   integer: sqliteIntegerDescriptor,
   real: sqliteRealDescriptor,