@prisma-next/target-sqlite 0.5.0-dev.60 → 0.5.0-dev.61

package/dist/{planner-target-details-DTIFFx4L.d.mts → planner-target-details-CtWRvse0.d.mts}

@@ -9,4 +9,4 @@ interface SqlitePlanTargetDetails {
 declare function buildTargetDetails(objectType: OperationClass, name: string, table?: string): SqlitePlanTargetDetails;
 //#endregion
 export { buildTargetDetails as n, SqlitePlanTargetDetails as t };
-//# sourceMappingURL=planner-target-details-DTIFFx4L.d.mts.map
+//# sourceMappingURL=planner-target-details-CtWRvse0.d.mts.map

package/dist/{planner-target-details-DTIFFx4L.d.mts.map → planner-target-details-CtWRvse0.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"planner-target-details-DTIFFx4L.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"sourcesContent":[],"mappings":";KAEY,cAAA;AAAA,UAMK,uBAAA,CANS;EAMT,SAAA,MAAA,EAAA,MAAA;EAaD,SAAA,UAAA,EAXO,cAYT;;;;iBADE,kBAAA,aACF,+CAGX"}
+{"version":3,"file":"planner-target-details-CtWRvse0.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"sourcesContent":[],"mappings":";KAEY,cAAA;AAAA,UAMK,uBAAA,CANS;EAMT,SAAA,MAAA,EAAA,MAAA;EAaD,SAAA,UAAA,EAXO,cAYT;;;;iBADE,kBAAA,aACF,+CAGX"}

package/dist/planner-target-details.d.mts

@@ -1,2 +1,2 @@
-import { n as buildTargetDetails, t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import { n as buildTargetDetails, t as SqlitePlanTargetDetails } from "./planner-target-details-CtWRvse0.mjs";
 export { type SqlitePlanTargetDetails, buildTargetDetails };

package/dist/planner.d.mts

@@ -1,8 +1,8 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
-import "./shared-BNtoZqdo.mjs";
-import "./sqlite-migration-BYgrMZdR.mjs";
-import "./op-factory-call-BPPSCdTB.mjs";
-import { n as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-RVneETNy.mjs";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-CtWRvse0.mjs";
+import "./shared-D_1fFqLf.mjs";
+import "./sqlite-migration-BeR1cikr.mjs";
+import "./op-factory-call-dUIOao68.mjs";
+import { n as TypeScriptRenderableSqliteMigration } from "./planner-produced-sqlite-migration-BfIIUtxe.mjs";
 import { MigrationOperationPolicy, SqlMigrationPlanner, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
 import { Contract } from "@prisma-next/contract/types";
 import { MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";

package/dist/render-ops.d.mts

@@ -1,6 +1,6 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
-import "./shared-BNtoZqdo.mjs";
-import { l as SqliteOpFactoryCall } from "./op-factory-call-BPPSCdTB.mjs";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-CtWRvse0.mjs";
+import "./shared-D_1fFqLf.mjs";
+import { l as SqliteOpFactoryCall } from "./op-factory-call-dUIOao68.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 
 //#region src/core/migrations/render-ops.d.ts

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/runtime-target.ts"],"sourcesContent":[],"mappings":";;;;UAKiB,2BAAA,SAAoC;AAArD,cAEM,6BAFuC,EAER,0BAFqC,CAAA,QAAA,EAIxE,2BAJwE,CAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/runtime-target.ts"],"sourcesContent":[],"mappings":";;;;UAIiB,2BAAA,SAAoC;AAArD,cAEM,6BAFuC,EAER,0BAFqC,CAAA,QAAA,EAIxE,2BAJwE,CAAA"}

package/dist/runtime.mjs

@@ -1,11 +1,9 @@
 import { t as sqliteTargetDescriptorMeta } from "./descriptor-meta-BA2YAFQq.mjs";
-import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 
 //#region src/core/runtime-target.ts
 const sqliteRuntimeTargetDescriptor = {
 	...sqliteTargetDescriptorMeta,
-	codecs: () => createCodecRegistry(),
-	parameterizedCodecs: () => [],
+	codecs: () => [],
 	create() {
 		return {
 			familyId: "sql",

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<\n  'sqlite',\n  SqliteRuntimeTargetInstance\n>"],"sources":["../src/core/runtime-target.ts"],"sourcesContent":["import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';\nimport { sqliteTargetDescriptorMeta } from './descriptor-meta';\n\nexport interface SqliteRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'sqlite'> {}\n\nconst sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<\n  'sqlite',\n  SqliteRuntimeTargetInstance\n> = {\n  ...sqliteTargetDescriptorMeta,\n  codecs: () => createCodecRegistry(),\n  parameterizedCodecs: () => [],\n  create(): SqliteRuntimeTargetInstance {\n    return {\n      familyId: 'sql',\n      targetId: 'sqlite',\n    };\n  },\n};\n\nexport default sqliteRuntimeTargetDescriptor;\n"],"mappings":";;;;AAOA,MAAMA,gCAGF;CACF,GAAG;CACH,cAAc,qBAAqB;CACnC,2BAA2B,EAAE;CAC7B,SAAsC;AACpC,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,6BAAe"}
+{"version":3,"file":"runtime.mjs","names":["sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<\n  'sqlite',\n  SqliteRuntimeTargetInstance\n>"],"sources":["../src/core/runtime-target.ts"],"sourcesContent":["import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';\nimport type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';\nimport { sqliteTargetDescriptorMeta } from './descriptor-meta';\n\nexport interface SqliteRuntimeTargetInstance extends RuntimeTargetInstance<'sql', 'sqlite'> {}\n\nconst sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<\n  'sqlite',\n  SqliteRuntimeTargetInstance\n> = {\n  ...sqliteTargetDescriptorMeta,\n  codecs: () => [],\n  create(): SqliteRuntimeTargetInstance {\n    return {\n      familyId: 'sql',\n      targetId: 'sqlite',\n    };\n  },\n};\n\nexport default sqliteRuntimeTargetDescriptor;\n"],"mappings":";;;AAMA,MAAMA,gCAGF;CACF,GAAG;CACH,cAAc,EAAE;CAChB,SAAsC;AACpC,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,6BAAe"}

package/dist/{shared-BNtoZqdo.d.mts → shared-D_1fFqLf.d.mts}

@@ -1,4 +1,4 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-CtWRvse0.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { ReferentialAction } from "@prisma-next/sql-contract/types";
 
@@ -66,4 +66,4 @@ interface SqliteIndexSpec {
 }
 //#endregion
 export { SqliteTableSpec as i, SqliteColumnSpec as n, SqliteIndexSpec as r, Op as t };
-//# sourceMappingURL=shared-BNtoZqdo.d.mts.map
+//# sourceMappingURL=shared-D_1fFqLf.d.mts.map

package/dist/{shared-BNtoZqdo.d.mts.map → shared-D_1fFqLf.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"shared-BNtoZqdo.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"sourcesContent":[],"mappings":";;;;;KAKY,EAAA,GAAK,0BAA0B;AAkC3C;AAKA;AAgBA;;;;;;AAYA;;;;;;;;UA7CiB,gBAAA;;;;;;;UAQA,oBAAA;;;UAIA,gBAAA;;;;UAKA,oBAAA;;;;;;;sBAOK;sBACA;;;;;;;UAQL,eAAA;6BACY;wBACL;8BACM;kCACI;;;;;;;UAQjB,eAAA"}
+{"version":3,"file":"shared-D_1fFqLf.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"sourcesContent":[],"mappings":";;;;;KAKY,EAAA,GAAK,0BAA0B;AAkC3C;AAKA;AAgBA;;;;;;AAYA;;;;;;;;UA7CiB,gBAAA;;;;;;;UAQA,oBAAA;;;UAIA,gBAAA;;;;UAKA,oBAAA;;;;;;;sBAOK;sBACA;;;;;;;UAQL,eAAA;6BACY;wBACL;8BACM;kCACI;;;;;;;UAQjB,eAAA"}

package/dist/{sqlite-migration-BYgrMZdR.d.mts → sqlite-migration-BeR1cikr.d.mts}

@@ -1,4 +1,4 @@
-import { t as SqlitePlanTargetDetails } from "./planner-target-details-DTIFFx4L.mjs";
+import { t as SqlitePlanTargetDetails } from "./planner-target-details-CtWRvse0.mjs";
 import { Migration } from "@prisma-next/family-sql/migration";
 
 //#region src/core/migrations/sqlite-migration.d.ts
@@ -15,4 +15,4 @@ declare abstract class SqliteMigration extends Migration<SqlitePlanTargetDetails
 }
 //#endregion
 export { SqliteMigration as t };
-//# sourceMappingURL=sqlite-migration-BYgrMZdR.d.mts.map
+//# sourceMappingURL=sqlite-migration-BeR1cikr.d.mts.map

package/dist/{sqlite-migration-BYgrMZdR.d.mts.map → sqlite-migration-BeR1cikr.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"sqlite-migration-BYgrMZdR.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;AAUA;;;;;uBAAsB,eAAA,SAAwB,UAAa"}
+{"version":3,"file":"sqlite-migration-BeR1cikr.d.mts","names":[],"sources":["../src/core/migrations/sqlite-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;AAUA;;;;;uBAAsB,eAAA,SAAwB,UAAa"}

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@prisma-next/target-sqlite",
-  "version": "0.5.0-dev.60",
+  "version": "0.5.0-dev.61",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@prisma-next/cli": "0.5.0-dev.60",
-    "@prisma-next/framework-components": "0.5.0-dev.60",
-    "@prisma-next/family-sql": "0.5.0-dev.60",
-    "@prisma-next/sql-contract": "0.5.0-dev.60",
-    "@prisma-next/contract": "0.5.0-dev.60",
-    "@prisma-next/migration-tools": "0.5.0-dev.60",
-    "@prisma-next/sql-errors": "0.5.0-dev.60",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.60",
-    "@prisma-next/sql-runtime": "0.5.0-dev.60",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.60",
-    "@prisma-next/ts-render": "0.5.0-dev.60",
-    "@prisma-next/errors": "0.5.0-dev.60",
-    "@prisma-next/utils": "0.5.0-dev.60"
+    "@prisma-next/cli": "0.5.0-dev.61",
+    "@prisma-next/errors": "0.5.0-dev.61",
+    "@prisma-next/family-sql": "0.5.0-dev.61",
+    "@prisma-next/framework-components": "0.5.0-dev.61",
+    "@prisma-next/migration-tools": "0.5.0-dev.61",
+    "@prisma-next/sql-contract": "0.5.0-dev.61",
+    "@prisma-next/sql-errors": "0.5.0-dev.61",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.61",
+    "@prisma-next/sql-runtime": "0.5.0-dev.61",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.61",
+    "@prisma-next/ts-render": "0.5.0-dev.61",
+    "@prisma-next/contract": "0.5.0-dev.61",
+    "@prisma-next/utils": "0.5.0-dev.61"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
+    "@prisma-next/driver-sqlite": "0.5.0-dev.61",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/driver-sqlite": "0.5.0-dev.60",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },

package/src/core/codec-helpers.ts

@@ -0,0 +1,11 @@
+/**
+ * Local `JsonValue` alias for the SQLite target. Codec implementations live in `codecs.ts` (TML-2357); this module retains only the JSON-shape alias the surrounding adapter and tests still import.
+ */
+
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { readonly [key: string]: JsonValue }
+  | readonly JsonValue[];

package/src/core/codecs.ts

@@ -1,4 +1,34 @@
-import { codec, defineCodecs, sqlCodecDefinitions } from '@prisma-next/sql-relational-core/ast';
+/**
+ * Native SQLite target codecs (TML-2357). Mirrors the Postgres codec class form in `packages/3-targets/3-targets/postgres/src/core/codecs.ts`.
+ *
+ * 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
+ * `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.
+ *
+ * Audit: every SQLite codec is non-parameterized and parameter-stateless; `factory()` takes no params (`P = void`) and returns a fresh codec constructed solely from `this`.
+ */
+
+import type { JsonValue } from '@prisma-next/contract/types';
+import {
+  type AnyCodecDescriptor,
+  type CodecCallContext,
+  CodecDescriptorImpl,
+  CodecImpl,
+  type CodecInstanceContext,
+  type ColumnHelperFor,
+  type ColumnHelperForStrict,
+  column,
+  voidParamsSchema,
+} from '@prisma-next/framework-components/codec';
+import {
+  sqlCharDescriptor,
+  sqlFloatDescriptor,
+  sqlIntDescriptor,
+  sqlVarcharDescriptor,
+} from '@prisma-next/sql-relational-core/ast';
 import {
   SQLITE_BIGINT_CODEC_ID,
   SQLITE_BLOB_CODEC_ID,
@@ -9,111 +39,299 @@ import {
   SQLITE_TEXT_CODEC_ID,
 } from './codec-ids';
 
-const sqlCharCodec = sqlCodecDefinitions.char.codec;
-const sqlVarcharCodec = sqlCodecDefinitions.varchar.codec;
-const sqlIntCodec = sqlCodecDefinitions.int.codec;
-const sqlFloatCodec = sqlCodecDefinitions.float.codec;
-
-export type JsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | { readonly [key: string]: JsonValue }
-  | readonly JsonValue[];
-
-const sqliteTextCodec = codec({
-  typeId: SQLITE_TEXT_CODEC_ID,
-  targetTypes: ['text'],
-  traits: ['equality', 'order', 'textual'],
-  encode: (value: string): string => value,
-  decode: (wire: string): string => wire,
-});
-
-const sqliteIntegerCodec = codec({
-  typeId: SQLITE_INTEGER_CODEC_ID,
-  targetTypes: ['integer'],
-  traits: ['equality', 'order', 'numeric'],
-  encode: (value: number): number => value,
-  decode: (wire: number): number => wire,
-});
-
-const sqliteRealCodec = codec({
-  typeId: SQLITE_REAL_CODEC_ID,
-  targetTypes: ['real'],
-  traits: ['equality', 'order', 'numeric'],
-  encode: (value: number): number => value,
-  decode: (wire: number): number => wire,
-});
-
-const sqliteBlobCodec = codec({
-  typeId: SQLITE_BLOB_CODEC_ID,
-  targetTypes: ['blob'],
-  traits: ['equality'],
-  encode: (value: Uint8Array): Uint8Array => value,
-  decode: (wire: Uint8Array): Uint8Array => wire,
-  encodeJson: (value: Uint8Array): string => Buffer.from(value).toString('base64'),
-  decodeJson: (json: JsonValue): Uint8Array => {
+export class SqliteTextCodec extends CodecImpl<
+  typeof SQLITE_TEXT_CODEC_ID,
+  readonly ['equality', 'order', 'textual'],
+  string,
+  string
+> {
+  async encode(value: string, _ctx: CodecCallContext): Promise<string> {
+    return value;
+  }
+  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
+    return wire;
+  }
+  encodeJson(value: string): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): string {
+    return json as string;
+  }
+}
+
+export class SqliteTextDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_TEXT_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'textual'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteTextCodec {
+    return () => new SqliteTextCodec(this);
+  }
+}
+
+export const sqliteTextDescriptor = new SqliteTextDescriptor();
+
+export const sqliteTextColumn = () =>
+  column(sqliteTextDescriptor.factory(), sqliteTextDescriptor.codecId, undefined, 'text');
+
+sqliteTextColumn satisfies ColumnHelperFor<SqliteTextDescriptor>;
+sqliteTextColumn satisfies ColumnHelperForStrict<SqliteTextDescriptor>;
+
+export class SqliteIntegerCodec extends CodecImpl<
+  typeof SQLITE_INTEGER_CODEC_ID,
+  readonly ['equality', 'order', 'numeric'],
+  number,
+  number
+> {
+  async encode(value: number, _ctx: CodecCallContext): Promise<number> {
+    return value;
+  }
+  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {
+    return wire;
+  }
+  encodeJson(value: number): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): number {
+    return json as number;
+  }
+}
+
+export class SqliteIntegerDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_INTEGER_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'numeric'] as const;
+  override readonly targetTypes = ['integer'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteIntegerCodec {
+    return () => new SqliteIntegerCodec(this);
+  }
+}
+
+export const sqliteIntegerDescriptor = new SqliteIntegerDescriptor();
+
+export const sqliteIntegerColumn = () =>
+  column(sqliteIntegerDescriptor.factory(), sqliteIntegerDescriptor.codecId, undefined, 'integer');
+
+sqliteIntegerColumn satisfies ColumnHelperFor<SqliteIntegerDescriptor>;
+sqliteIntegerColumn satisfies ColumnHelperForStrict<SqliteIntegerDescriptor>;
+
+export class SqliteRealCodec extends CodecImpl<
+  typeof SQLITE_REAL_CODEC_ID,
+  readonly ['equality', 'order', 'numeric'],
+  number,
+  number
+> {
+  async encode(value: number, _ctx: CodecCallContext): Promise<number> {
+    return value;
+  }
+  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {
+    return wire;
+  }
+  encodeJson(value: number): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): number {
+    return json as number;
+  }
+}
+
+export class SqliteRealDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_REAL_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'numeric'] as const;
+  override readonly targetTypes = ['real'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteRealCodec {
+    return () => new SqliteRealCodec(this);
+  }
+}
+
+export const sqliteRealDescriptor = new SqliteRealDescriptor();
+
+export const sqliteRealColumn = () =>
+  column(sqliteRealDescriptor.factory(), sqliteRealDescriptor.codecId, undefined, 'real');
+
+sqliteRealColumn satisfies ColumnHelperFor<SqliteRealDescriptor>;
+sqliteRealColumn satisfies ColumnHelperForStrict<SqliteRealDescriptor>;
+
+export class SqliteBlobCodec extends CodecImpl<
+  typeof SQLITE_BLOB_CODEC_ID,
+  readonly ['equality'],
+  Uint8Array,
+  Uint8Array
+> {
+  async encode(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {
+    return value;
+  }
+  async decode(wire: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {
+    return wire;
+  }
+  encodeJson(value: Uint8Array): JsonValue {
+    return Buffer.from(value).toString('base64');
+  }
+  decodeJson(json: JsonValue): Uint8Array {
     if (typeof json !== 'string') {
       throw new TypeError('sqlite/blob@1 contract value must be a base64 string');
     }
     return new Uint8Array(Buffer.from(json, 'base64'));
-  },
-});
-
-const sqliteDatetimeCodec = codec({
-  typeId: SQLITE_DATETIME_CODEC_ID,
-  targetTypes: ['text'],
-  traits: ['equality', 'order'],
-  encode: (value: Date): string => value.toISOString(),
-  decode: (wire: string): Date => new Date(wire),
-  encodeJson: (value: Date): string => value.toISOString(),
-  decodeJson: (json: JsonValue): Date => {
+  }
+}
+
+export class SqliteBlobDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_BLOB_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['blob'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteBlobCodec {
+    return () => new SqliteBlobCodec(this);
+  }
+}
+
+export const sqliteBlobDescriptor = new SqliteBlobDescriptor();
+
+export const sqliteBlobColumn = () =>
+  column(sqliteBlobDescriptor.factory(), sqliteBlobDescriptor.codecId, undefined, 'blob');
+
+sqliteBlobColumn satisfies ColumnHelperFor<SqliteBlobDescriptor>;
+sqliteBlobColumn satisfies ColumnHelperForStrict<SqliteBlobDescriptor>;
+
+export class SqliteDatetimeCodec extends CodecImpl<
+  typeof SQLITE_DATETIME_CODEC_ID,
+  readonly ['equality', 'order'],
+  string,
+  Date
+> {
+  // Reject `Invalid Date` (NaN-time) at every decode ingress so consumers never receive a Date object whose downstream operations silently produce NaN. Mirrors the stricter ISO-8601 validation on the postgres timestamp helpers.
+  private parseDate(value: string): Date {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+      throw new TypeError(`sqlite/datetime@1 value must be a valid ISO-8601 string: ${value}`);
+    }
+    return date;
+  }
+  async encode(value: Date, _ctx: CodecCallContext): Promise<string> {
+    return value.toISOString();
+  }
+  async decode(wire: string, _ctx: CodecCallContext): Promise<Date> {
+    return this.parseDate(wire);
+  }
+  encodeJson(value: Date): JsonValue {
+    return value.toISOString();
+  }
+  decodeJson(json: JsonValue): Date {
     if (typeof json !== 'string') {
       throw new TypeError('sqlite/datetime@1 contract value must be an ISO-8601 string');
     }
-    return new Date(json);
-  },
-});
-
-const sqliteJsonCodec = codec({
-  typeId: SQLITE_JSON_CODEC_ID,
-  targetTypes: ['text'],
-  traits: ['equality'],
-  encode: (value: JsonValue): string => JSON.stringify(value),
-  decode: (wire: string | JsonValue): JsonValue =>
-    typeof wire === 'string' ? (JSON.parse(wire) as JsonValue) : wire,
-});
-
-const sqliteBigintCodec = codec({
-  typeId: SQLITE_BIGINT_CODEC_ID,
-  targetTypes: ['integer'],
-  traits: ['equality', 'order', 'numeric'],
-  encode: (value: bigint): number | bigint => value,
-  decode: (wire: number | bigint): bigint => BigInt(wire),
-  encodeJson: (value: bigint): string => value.toString(),
-  decodeJson: (json: JsonValue): bigint => {
+    return this.parseDate(json);
+  }
+}
+
+export class SqliteDatetimeDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_DATETIME_CODEC_ID;
+  override readonly traits = ['equality', 'order'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteDatetimeCodec {
+    return () => new SqliteDatetimeCodec(this);
+  }
+}
+
+export const sqliteDatetimeDescriptor = new SqliteDatetimeDescriptor();
+
+export const sqliteDatetimeColumn = () =>
+  column(sqliteDatetimeDescriptor.factory(), sqliteDatetimeDescriptor.codecId, undefined, 'text');
+
+sqliteDatetimeColumn satisfies ColumnHelperFor<SqliteDatetimeDescriptor>;
+sqliteDatetimeColumn satisfies ColumnHelperForStrict<SqliteDatetimeDescriptor>;
+
+export class SqliteJsonCodec extends CodecImpl<
+  typeof SQLITE_JSON_CODEC_ID,
+  readonly ['equality'],
+  string | JsonValue,
+  JsonValue
+> {
+  async encode(value: JsonValue, _ctx: CodecCallContext): Promise<string> {
+    return JSON.stringify(value);
+  }
+  async decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue> {
+    return typeof wire === 'string' ? (JSON.parse(wire) as JsonValue) : wire;
+  }
+  encodeJson(value: JsonValue): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): JsonValue {
+    return json;
+  }
+}
+
+export class SqliteJsonDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_JSON_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteJsonCodec {
+    return () => new SqliteJsonCodec(this);
+  }
+}
+
+export const sqliteJsonDescriptor = new SqliteJsonDescriptor();
+
+export const sqliteJsonColumn = () =>
+  column(sqliteJsonDescriptor.factory(), sqliteJsonDescriptor.codecId, undefined, 'text');
+
+sqliteJsonColumn satisfies ColumnHelperFor<SqliteJsonDescriptor>;
+sqliteJsonColumn satisfies ColumnHelperForStrict<SqliteJsonDescriptor>;
+
+export class SqliteBigintCodec extends CodecImpl<
+  typeof SQLITE_BIGINT_CODEC_ID,
+  readonly ['equality', 'order', 'numeric'],
+  number | bigint,
+  bigint
+> {
+  async encode(value: bigint, _ctx: CodecCallContext): Promise<number | bigint> {
+    return value;
+  }
+  async decode(wire: number | bigint, _ctx: CodecCallContext): Promise<bigint> {
+    return BigInt(wire);
+  }
+  encodeJson(value: bigint): JsonValue {
+    return value.toString();
+  }
+  decodeJson(json: JsonValue): bigint {
     if (typeof json !== 'string' && typeof json !== 'number') {
       throw new TypeError('sqlite/bigint@1 contract value must be a string or number');
     }
     return BigInt(json);
-  },
-});
-
-const codecs = defineCodecs()
-  .add('char', sqlCharCodec)
-  .add('varchar', sqlVarcharCodec)
-  .add('int', sqlIntCodec)
-  .add('float', sqlFloatCodec)
-  .add('text', sqliteTextCodec)
-  .add('integer', sqliteIntegerCodec)
-  .add('real', sqliteRealCodec)
-  .add('blob', sqliteBlobCodec)
-  .add('datetime', sqliteDatetimeCodec)
-  .add('json', sqliteJsonCodec)
-  .add('bigint', sqliteBigintCodec);
-
-export const codecDefinitions = codecs.codecDefinitions;
-export const dataTypes = codecs.dataTypes;
-
-export type CodecTypes = typeof codecs.CodecTypes;
+  }
+}
+
+export class SqliteBigintDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = SQLITE_BIGINT_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'numeric'] as const;
+  override readonly targetTypes = ['integer'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => SqliteBigintCodec {
+    return () => new SqliteBigintCodec(this);
+  }
+}
+
+export const sqliteBigintDescriptor = new SqliteBigintDescriptor();
+
+export const sqliteBigintColumn = () =>
+  column(sqliteBigintDescriptor.factory(), sqliteBigintDescriptor.codecId, undefined, 'integer');
+
+sqliteBigintColumn satisfies ColumnHelperFor<SqliteBigintDescriptor>;
+sqliteBigintColumn satisfies ColumnHelperForStrict<SqliteBigintDescriptor>;
+
+export const codecDescriptors: readonly AnyCodecDescriptor[] = [
+  sqlCharDescriptor,
+  sqlVarcharDescriptor,
+  sqlIntDescriptor,
+  sqlFloatDescriptor,
+  sqliteTextDescriptor,
+  sqliteIntegerDescriptor,
+  sqliteRealDescriptor,
+  sqliteBlobDescriptor,
+  sqliteDatetimeDescriptor,
+  sqliteJsonDescriptor,
+  sqliteBigintDescriptor,
+];

package/src/core/descriptor-meta.ts

@@ -1,5 +1,5 @@
+import type { CodecTypes } from '../exports/codec-types';
 import { sqliteAuthoringFieldPresets } from './authoring';
-import type { CodecTypes } from './codecs';
 
 const sqliteTargetDescriptorMetaBase = {
   kind: 'target',

package/src/core/registry.ts

@@ -0,0 +1,11 @@
+import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
+import type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { codecDescriptors } from './codecs';
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/target-sqlite`.
+ *
+ * Public consumer surface for the sqlite codec set: the sqlite adapter and any other consumer that needs to enumerate or look up a sqlite codec by id consumes this rather than the raw descriptor array. See ADR 208.
+ */
+export const sqliteCodecRegistry: CodecDescriptorRegistry =
+  buildCodecDescriptorRegistry(codecDescriptors);

package/src/core/runtime-target.ts

@@ -1,5 +1,4 @@
 import type { RuntimeTargetInstance } from '@prisma-next/framework-components/execution';
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import type { SqlRuntimeTargetDescriptor } from '@prisma-next/sql-runtime';
 import { sqliteTargetDescriptorMeta } from './descriptor-meta';
 
@@ -10,8 +9,7 @@ const sqliteRuntimeTargetDescriptor: SqlRuntimeTargetDescriptor<
   SqliteRuntimeTargetInstance
 > = {
   ...sqliteTargetDescriptorMeta,
-  codecs: () => createCodecRegistry(),
-  parameterizedCodecs: () => [],
+  codecs: () => [],
   create(): SqliteRuntimeTargetInstance {
     return {
       familyId: 'sql',