@prisma/orm-target-sqlite 8.0.0-rc.2-dev.2 → 8.0.0-rc.20-dev.1

package/dist/{codec-descriptor-B9ru99aI-DTkdKFU5.mjs → codec-descriptor-DRmF-crq-BALI5Jtz.mjs}

@@ -1,7 +1,8 @@
 import { CodecDescriptorImpl, validateCodecTypeParams } from "@prisma/orm-framework/components/codec";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-//#region ../../../3-targets/3-targets/sqlite/dist/codec-descriptor-B9ru99aI.mjs
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+//#region ../../../3-targets/sqlite/1-target/dist/codec-descriptor-DRmF-crq.mjs
 const SQLITE_CODEC_DESCRIPTOR_KIND = "sqlite-codec";
 var SqliteCodecDescriptor = class extends CodecDescriptorImpl {
 	descriptorKind = SQLITE_CODEC_DESCRIPTOR_KIND;
@@ -18,34 +19,29 @@ var SqliteCodecDescriptor = class extends CodecDescriptorImpl {
 	}
 };
 var SqliteCodecDescriptorAdapter = class extends SqliteCodecDescriptor {
-	descriptor;
 	options;
+	dataType;
 	codecId;
 	traits;
-	targetTypes;
 	paramsSchema;
 	renderOutputType;
 	renderInputType;
 	renderValueLiteral;
 	constructor(descriptor, options) {
 		super();
-		this.descriptor = descriptor;
 		this.options = options;
+		this.dataType = options.dataType.id;
 		this.codecId = descriptor.codecId;
 		this.traits = descriptor.traits;
-		this.targetTypes = descriptor.targetTypes;
-		this.paramsSchema = descriptor.paramsSchema;
+		this.paramsSchema = blindCast(options.dataType.params);
 		const renderOutputType = descriptor.renderOutputType;
 		if (renderOutputType !== void 0) this.renderOutputType = (params) => renderOutputType.call(descriptor, params);
 		const renderInputType = descriptor.renderInputType;
 		if (renderInputType !== void 0) this.renderInputType = (params) => renderInputType.call(descriptor, params);
-		const renderValueLiteral = descriptor.renderValueLiteral;
-		if (renderValueLiteral !== void 0) this.renderValueLiteral = (value, side) => renderValueLiteral.call(descriptor, value, side);
-	}
-	get isParameterized() {
-		return this.descriptor.isParameterized;
+		if (descriptor.renderValueLiteral !== void 0) throw new InternalError(`${descriptor.codecId} is a family codec template with its own renderValueLiteral. A family template renders no literal, because only the target knows the form its data type stores a value in; pass renderValueLiteral in the options instead.`);
+		if (options.renderValueLiteral !== void 0) this.renderValueLiteral = options.renderValueLiteral;
 	}
-	factory = (params) => this.descriptor.factory(params);
+	factory = (params) => this.options.factory(this, this.options.dataType, params);
 	jsonProjection(expression, params) {
 		return this.options.jsonProjection(expression, params);
 	}
@@ -57,7 +53,7 @@ function defineSqliteCodecs(descriptors) {
 	return descriptors;
 }
 function isSqliteCodecDescriptor(value) {
-	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";
+	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) && "paramsSchema" in value && (value.paramsSchema === void 0 || 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) {
 	return typeof value === "object" && value !== null || typeof value === "function";
@@ -104,4 +100,4 @@ function candidateCodecId(value) {
 //#endregion
 export { sqliteCodec as a, isSqliteCodecDescriptor as i, buildSqliteCodecDescriptorRegistry as n, defineSqliteCodecs as r, SqliteCodecDescriptor as t };
 
-//# sourceMappingURL=codec-descriptor-B9ru99aI-DTkdKFU5.mjs.map
+//# sourceMappingURL=codec-descriptor-DRmF-crq-BALI5Jtz.mjs.map

package/dist/codec-descriptor-DRmF-crq-BALI5Jtz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-descriptor-DRmF-crq-BALI5Jtz.mjs","names":["#descriptors"],"sources":["../../../../3-targets/sqlite/1-target/dist/codec-descriptor-DRmF-crq.mjs"],"sourcesContent":["import { CodecDescriptorImpl, validateCodecTypeParams } from \"@internal/framework-components/codec\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { InternalError } from \"@internal/utils/internal-error\";\n//#region src/core/codec-descriptor.ts\nconst SQLITE_CODEC_DESCRIPTOR_KIND = \"sqlite-codec\";\nvar SqliteCodecDescriptor = class extends CodecDescriptorImpl {\n\tdescriptorKind = SQLITE_CODEC_DESCRIPTOR_KIND;\n\tprojectJson(expression, ref) {\n\t\tif (ref.many === true) throw structuredError(\"RUNTIME.CODEC_DESCRIPTOR_ARRAY_UNSUPPORTED\", `Codec '${ref.codecId}' uses CodecRef.many, but SQLite codec descriptors do not support stored scalar arrays.`, {\n\t\t\twhy: \"SQLite has no stored scalar-array codec protocol, so applying a scalar projection to the whole stored array would be ambiguous.\",\n\t\t\tfix: \"Use a scalar CodecRef or introduce an explicit target representation before projecting stored arrays.\",\n\t\t\tmeta: { codecId: ref.codecId }\n\t\t});\n\t\treturn this.jsonProjection(expression, this.validateParams(ref));\n\t}\n\tvalidateParams(ref) {\n\t\treturn blindCast(validateCodecTypeParams(this, ref));\n\t}\n};\nvar SqliteCodecDescriptorAdapter = class extends SqliteCodecDescriptor {\n\toptions;\n\tdataType;\n\tcodecId;\n\ttraits;\n\tparamsSchema;\n\trenderOutputType;\n\trenderInputType;\n\trenderValueLiteral;\n\tconstructor(descriptor, options) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.dataType = options.dataType.id;\n\t\tthis.codecId = descriptor.codecId;\n\t\tthis.traits = descriptor.traits;\n\t\tthis.paramsSchema = blindCast(options.dataType.params);\n\t\tconst renderOutputType = descriptor.renderOutputType;\n\t\tif (renderOutputType !== void 0) this.renderOutputType = (params) => renderOutputType.call(descriptor, params);\n\t\tconst renderInputType = descriptor.renderInputType;\n\t\tif (renderInputType !== void 0) this.renderInputType = (params) => renderInputType.call(descriptor, params);\n\t\tif (descriptor.renderValueLiteral !== void 0) throw new InternalError(`${descriptor.codecId} is a family codec template with its own renderValueLiteral. A family template renders no literal, because only the target knows the form its data type stores a value in; pass renderValueLiteral in the options instead.`);\n\t\tif (options.renderValueLiteral !== void 0) this.renderValueLiteral = options.renderValueLiteral;\n\t}\n\tfactory = (params) => this.options.factory(this, this.options.dataType, params);\n\tjsonProjection(expression, params) {\n\t\treturn this.options.jsonProjection(expression, params);\n\t}\n};\nfunction sqliteCodec(descriptor, options) {\n\treturn blindCast(new SqliteCodecDescriptorAdapter(descriptor, options));\n}\nfunction defineSqliteCodecs(descriptors) {\n\treturn descriptors;\n}\nfunction isSqliteCodecDescriptor(value) {\n\treturn 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) && \"paramsSchema\" in value && (value.paramsSchema === void 0 || 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\";\n}\nfunction isObjectLike(value) {\n\treturn typeof value === \"object\" && value !== null || typeof value === \"function\";\n}\nvar SqliteCodecDescriptorRegistryImpl = class {\n\t#descriptors;\n\tconstructor(descriptors) {\n\t\tthis.#descriptors = descriptors;\n\t\tObject.freeze(this);\n\t}\n\tdescriptorFor(codecId) {\n\t\treturn this.#descriptors.get(codecId);\n\t}\n\t*values() {\n\t\tyield* this.#descriptors.values();\n\t}\n};\nfunction buildSqliteCodecDescriptorRegistry(descriptors) {\n\tconst byId = /* @__PURE__ */ new Map();\n\tfor (const descriptor of descriptors) {\n\t\tif (!isSqliteCodecDescriptor(descriptor)) {\n\t\t\tconst codecId = candidateCodecId(descriptor);\n\t\t\tthrow structuredError(\"RUNTIME.CODEC_DESCRIPTOR_INVALID\", `Codec descriptor '${codecId}' is not a valid SQLite codec descriptor.`, {\n\t\t\t\twhy: \"SQLite codec registries require the sqlite-codec discriminant and complete target descriptor methods.\",\n\t\t\t\tfix: \"Extend SqliteCodecDescriptor or adapt a generic descriptor with sqliteCodec().\",\n\t\t\t\tmeta: { codecId }\n\t\t\t});\n\t\t}\n\t\tif (byId.has(descriptor.codecId)) throw structuredError(\"RUNTIME.DUPLICATE_CODEC\", `Duplicate SQLite codec descriptor id '${descriptor.codecId}'.`, {\n\t\t\twhy: \"Each codecId must resolve to exactly one SQLite descriptor during registry composition.\",\n\t\t\tfix: \"Remove the duplicate target, adapter, or extension contribution.\",\n\t\t\tmeta: {\n\t\t\t\tcodecId: descriptor.codecId,\n\t\t\t\ttarget: \"sqlite\"\n\t\t\t}\n\t\t});\n\t\tbyId.set(descriptor.codecId, descriptor);\n\t}\n\treturn new SqliteCodecDescriptorRegistryImpl(byId);\n}\nfunction candidateCodecId(value) {\n\treturn typeof value === \"object\" && value !== null && \"codecId\" in value && typeof value.codecId === \"string\" ? value.codecId : \"<unknown>\";\n}\n//#endregion\nexport { sqliteCodec as a, isSqliteCodecDescriptor as i, buildSqliteCodecDescriptorRegistry as n, defineSqliteCodecs as r, SqliteCodecDescriptor as t };\n\n//# sourceMappingURL=codec-descriptor-DRmF-crq.mjs.map"],"mappings":"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"}

package/dist/codec-descriptor-DuW-d9ef-BBRBN0Ri.d.mts

@@ -0,0 +1,45 @@
+import { ProjectionExpr } from "@prisma/orm-family-sql/relational-core/ast";
+import { AnyCodecDescriptor, AnyCodecDescriptorTemplate, Codec, CodecDescriptor, CodecDescriptorImpl, CodecDescriptorTemplate, CodecInstanceContext, CodecRef as CodecRef$1, CodecTrait, DataType } from "@prisma/orm-framework/components/codec";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/sqlite/1-target/dist/codec-descriptor-DuW-d9ef.d.mts
+//#region src/core/codec-descriptor.d.ts
+declare const SQLITE_CODEC_DESCRIPTOR_KIND: "sqlite-codec";
+interface AnySqliteCodecDescriptor extends AnyCodecDescriptor {
+  readonly descriptorKind: typeof SQLITE_CODEC_DESCRIPTOR_KIND;
+  projectJson(expression: ProjectionExpr, ref: CodecRef$1): ProjectionExpr;
+}
+declare abstract class SqliteCodecDescriptor<P = void> extends CodecDescriptorImpl<P> implements AnySqliteCodecDescriptor {
+  readonly descriptorKind: "sqlite-codec";
+  protected abstract jsonProjection(expression: ProjectionExpr, params: P): ProjectionExpr;
+  projectJson(expression: ProjectionExpr, ref: CodecRef$1): ProjectionExpr;
+  private validateParams;
+}
+type DescriptorParams<D extends AnyCodecDescriptorTemplate> = D extends CodecDescriptorTemplate<infer P> ? P : never;
+/** The codec the family descriptor's factory builds, which a `factory` option's codec extends. */
+type DescriptorCodec<D extends AnyCodecDescriptorTemplate> = ReturnType<ReturnType<D['factory']>>;
+interface SqliteCodecOptions<P, C extends Codec<string, readonly CodecTrait[], unknown, unknown> = Codec<string, readonly CodecTrait[], unknown, unknown>> {
+  /**
+   * The data type the adapted codec represents here. A template names none; this target does. The
+   * adapted codec's parameter schema is this data type's, not the template's.
+   */
+  readonly dataType: DataType;
+  /** Renders the literal of the value the codec reads from a stored value of `dataType`. A family template renders no literal, because only the target knows the form its data type stores a value in, so the adapted codec renders with this and never with a renderer on the template. */
+  readonly renderValueLiteral?: (value: JsonValue, side: 'output' | 'input') => string | undefined;
+  readonly jsonProjection: (expression: ProjectionExpr, params: P) => ProjectionExpr;
+  /**
+   * Builds the codec: the family codec, or a subclass with SQLite's own rules, constructed with `dataType` and the column's parameters, because a family template names no data type and so builds no codec of its own.
+   */
+  readonly factory: (descriptor: SqliteCodecDescriptor<P>, dataType: DataType, params: P) => (ctx: CodecInstanceContext) => C;
+}
+type AdaptedSqliteCodecDescriptor<D extends AnyCodecDescriptorTemplate> = Pick<D, keyof CodecDescriptorTemplate<DescriptorParams<D>>> & Pick<CodecDescriptor, 'dataType'> & Pick<AnySqliteCodecDescriptor, 'descriptorKind' | 'projectJson'>;
+declare function sqliteCodec<D extends AnyCodecDescriptorTemplate>(descriptor: D, options: SqliteCodecOptions<DescriptorParams<D>, DescriptorCodec<D>>): AdaptedSqliteCodecDescriptor<D>;
+declare function defineSqliteCodecs<const Descriptors extends readonly AnySqliteCodecDescriptor[]>(descriptors: Descriptors): Descriptors;
+declare function isSqliteCodecDescriptor(value: unknown): value is AnySqliteCodecDescriptor;
+interface SqliteCodecDescriptorRegistry {
+  descriptorFor(codecId: string): AnySqliteCodecDescriptor | undefined;
+  values(): IterableIterator<AnySqliteCodecDescriptor>;
+}
+declare function buildSqliteCodecDescriptorRegistry(descriptors: ReadonlyArray<unknown>): SqliteCodecDescriptorRegistry;
+//#endregion
+export { SqliteCodecOptions as a, isSqliteCodecDescriptor as c, SqliteCodecDescriptorRegistry as i, sqliteCodec as l, AnySqliteCodecDescriptor as n, buildSqliteCodecDescriptorRegistry as o, SqliteCodecDescriptor as r, defineSqliteCodecs as s, AdaptedSqliteCodecDescriptor as t };
+//# sourceMappingURL=codec-descriptor-DuW-d9ef-BBRBN0Ri.d.mts.map

package/dist/codec-descriptor-DuW-d9ef-BBRBN0Ri.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-descriptor-DuW-d9ef-BBRBN0Ri.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/codec-descriptor-DuW-d9ef.d.mts"],"mappings":";;;;;cAIc;UACJ,iCAAiC;WAChC,uBAAuB;EAChC,YAAY,YAAY,gBAAgB,KAAK,aAAa;;uBAErC,sBAAsB,kBAAkB,oBAAoB,cAAc;WACtF;qBACU,eAAe,YAAY,gBAAgB,QAAQ,IAAI;EAC1E,YAAY,YAAY,gBAAgB,KAAK,aAAa;UAClD;;KAEL,iBAAiB,UAAU,8BAA8B,UAAU,8BAA8B,KAAK;;KAEtG,gBAAgB,UAAU,8BAA8B,WAAW,WAAW;UACzE,mBAAmB,GAAG,UAAU,uBAAuB,kCAAkC,uBAAuB;;;;;WAK/G,UAAU;;WAEV,sBAAsB,OAAO,WAAW;WACxC,iBAAiB,YAAY,gBAAgB,QAAQ,MAAM;;;;WAI3D,UAAU,YAAY,sBAAsB,IAAI,UAAU,UAAU,QAAQ,OAAO,KAAK,yBAAyB;;KAEvH,6BAA6B,UAAU,8BAA8B,KAAK,SAAS,wBAAwB,iBAAiB,OAAO,KAAK,+BAA+B,KAAK;iBAChK,YAAY,UAAU,4BAA4B,YAAY,GAAG,SAAS,mBAAmB,iBAAiB,IAAI,gBAAgB,MAAM,6BAA6B;iBACrK,yBAAyB,6BAA6B,4BAA4B,aAAa,cAAc;iBAC7G,wBAAwB,iBAAiB,SAAS;UACzD;EACR,cAAc,kBAAkB;EAChC,UAAU,iBAAiB;;iBAEZ,mCAAmC,aAAa,yBAAyB"}

package/dist/codec-ids-CMbhYIsa.d.mts

@@ -0,0 +1 @@
+import "./codec-ids-DuJYssXV-BPKbFNRL.mjs";

package/dist/{codec-ids-CzeDyMWW-BZAcI50I.d.mts → codec-ids-DuJYssXV-BPKbFNRL.d.mts}

@@ -1,5 +1,5 @@
-import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma/orm-family-sql/relational-core/ast";
-//#region ../../../3-targets/3-targets/sqlite/dist/codec-ids-CzeDyMWW.d.mts
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_RAW_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma/orm-family-sql/relational-core/ast";
+//#region ../../../3-targets/sqlite/1-target/dist/codec-ids-DuJYssXV.d.mts
 //#region src/core/codec-ids.d.ts
 declare const SQLITE_TEXT_CODEC_ID: "sqlite/text@1";
 declare const SQLITE_INTEGER_CODEC_ID: "sqlite/integer@1";
@@ -10,5 +10,5 @@ declare const SQLITE_JSON_CODEC_ID: "sqlite/json@1";
 declare const SQLITE_BIGINT_CODEC_ID: "sqlite/bigint@1";
 declare const SQLITE_BIGINT_NUMBER_CODEC_ID: "sqlite/bigintnumber@1";
 //#endregion
-export { SQLITE_INTEGER_CODEC_ID as a, SQLITE_TEXT_CODEC_ID as c, SQL_INT_CODEC_ID as d, SQL_VARCHAR_CODEC_ID as f, SQLITE_DATETIME_CODEC_ID as i, SQL_CHAR_CODEC_ID as l, SQLITE_BIGINT_NUMBER_CODEC_ID as n, SQLITE_JSON_CODEC_ID as o, SQLITE_BLOB_CODEC_ID as r, SQLITE_REAL_CODEC_ID as s, SQLITE_BIGINT_CODEC_ID as t, SQL_FLOAT_CODEC_ID as u };
-//# sourceMappingURL=codec-ids-CzeDyMWW-BZAcI50I.d.mts.map
+export { SQLITE_INTEGER_CODEC_ID as a, SQLITE_TEXT_CODEC_ID as c, SQL_INT_CODEC_ID as d, SQL_RAW_CODEC_ID as f, SQLITE_DATETIME_CODEC_ID as i, SQL_CHAR_CODEC_ID as l, SQLITE_BIGINT_NUMBER_CODEC_ID as n, SQLITE_JSON_CODEC_ID as o, SQL_VARCHAR_CODEC_ID as p, SQLITE_BLOB_CODEC_ID as r, SQLITE_REAL_CODEC_ID as s, SQLITE_BIGINT_CODEC_ID as t, SQL_FLOAT_CODEC_ID as u };
+//# sourceMappingURL=codec-ids-DuJYssXV-BPKbFNRL.d.mts.map

package/dist/codec-ids-DuJYssXV-BPKbFNRL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-DuJYssXV-BPKbFNRL.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/codec-ids-DuJYssXV.d.mts"],"mappings":";;;cAEc;cACA;cACA;cACA;cACA;cACA;cACA;cACA"}

package/dist/{codec-ids-KMliSCRp-BhTbmbGr.mjs → codec-ids-wgEvkCkg-WltuexMR.mjs}

@@ -1,5 +1,5 @@
-import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma/orm-family-sql/relational-core/ast";
-//#region ../../../3-targets/3-targets/sqlite/dist/codec-ids-KMliSCRp.mjs
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_RAW_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma/orm-family-sql/relational-core/ast";
+//#region ../../../3-targets/sqlite/1-target/dist/codec-ids-wgEvkCkg.mjs
 const SQLITE_TEXT_CODEC_ID = "sqlite/text@1";
 const SQLITE_INTEGER_CODEC_ID = "sqlite/integer@1";
 const SQLITE_REAL_CODEC_ID = "sqlite/real@1";
@@ -9,6 +9,6 @@ const SQLITE_JSON_CODEC_ID = "sqlite/json@1";
 const SQLITE_BIGINT_CODEC_ID = "sqlite/bigint@1";
 const SQLITE_BIGINT_NUMBER_CODEC_ID = "sqlite/bigintnumber@1";
 //#endregion
-export { SQLITE_INTEGER_CODEC_ID as a, SQLITE_TEXT_CODEC_ID as c, SQL_INT_CODEC_ID as d, SQL_VARCHAR_CODEC_ID as f, SQLITE_DATETIME_CODEC_ID as i, SQL_CHAR_CODEC_ID as l, SQLITE_BIGINT_NUMBER_CODEC_ID as n, SQLITE_JSON_CODEC_ID as o, SQLITE_BLOB_CODEC_ID as r, SQLITE_REAL_CODEC_ID as s, SQLITE_BIGINT_CODEC_ID as t, SQL_FLOAT_CODEC_ID as u };
+export { SQLITE_INTEGER_CODEC_ID as a, SQLITE_TEXT_CODEC_ID as c, SQL_INT_CODEC_ID as d, SQL_RAW_CODEC_ID as f, SQLITE_DATETIME_CODEC_ID as i, SQL_CHAR_CODEC_ID as l, SQLITE_BIGINT_NUMBER_CODEC_ID as n, SQLITE_JSON_CODEC_ID as o, SQL_VARCHAR_CODEC_ID as p, SQLITE_BLOB_CODEC_ID as r, SQLITE_REAL_CODEC_ID as s, SQLITE_BIGINT_CODEC_ID as t, SQL_FLOAT_CODEC_ID as u };
 
-//# sourceMappingURL=codec-ids-KMliSCRp-BhTbmbGr.mjs.map
+//# sourceMappingURL=codec-ids-wgEvkCkg-WltuexMR.mjs.map

package/dist/codec-ids-wgEvkCkg-WltuexMR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-wgEvkCkg-WltuexMR.mjs","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/codec-ids-wgEvkCkg.mjs"],"sourcesContent":["import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_RAW_CODEC_ID, SQL_VARCHAR_CODEC_ID } from \"@internal/sql-relational-core/ast\";\n//#region src/core/codec-ids.ts\nconst SQLITE_TEXT_CODEC_ID = \"sqlite/text@1\";\nconst SQLITE_INTEGER_CODEC_ID = \"sqlite/integer@1\";\nconst SQLITE_REAL_CODEC_ID = \"sqlite/real@1\";\nconst SQLITE_BLOB_CODEC_ID = \"sqlite/blob@1\";\nconst SQLITE_DATETIME_CODEC_ID = \"sqlite/datetime@1\";\nconst SQLITE_JSON_CODEC_ID = \"sqlite/json@1\";\nconst SQLITE_BIGINT_CODEC_ID = \"sqlite/bigint@1\";\nconst SQLITE_BIGINT_NUMBER_CODEC_ID = \"sqlite/bigintnumber@1\";\n//#endregion\nexport { SQLITE_INTEGER_CODEC_ID as a, SQLITE_TEXT_CODEC_ID as c, SQL_INT_CODEC_ID as d, SQL_RAW_CODEC_ID as f, SQLITE_DATETIME_CODEC_ID as i, SQL_CHAR_CODEC_ID as l, SQLITE_BIGINT_NUMBER_CODEC_ID as n, SQLITE_JSON_CODEC_ID as o, SQL_VARCHAR_CODEC_ID as p, SQLITE_BLOB_CODEC_ID as r, SQLITE_REAL_CODEC_ID as s, SQLITE_BIGINT_CODEC_ID as t, SQL_FLOAT_CODEC_ID as u };\n\n//# sourceMappingURL=codec-ids-wgEvkCkg.mjs.map"],"mappings":";;AAEA,MAAM,uBAAuB;AAC7B,MAAM,0BAA0B;AAChC,MAAM,uBAAuB;AAC7B,MAAM,uBAAuB;AAC7B,MAAM,2BAA2B;AACjC,MAAM,uBAAuB;AAC7B,MAAM,yBAAyB;AAC/B,MAAM,gCAAgC"}

package/dist/{codec-types-D7uWRvQ1-DPnvquS8.d.mts → codec-types-COh75Bop-CUehAexc.d.mts}

@@ -1,8 +1,8 @@
-import { t as AdaptedSqliteCodecDescriptor } from "./codec-descriptor-BcgD9f3L-yDi5nh_k.mjs";
-import "./codec-descriptor-rFuZ9DzY-CKRIRxah.mjs";
-import { a as SqliteDatetimeDescriptor, c as SqliteRealDescriptor, i as SqliteBlobDescriptor, l as SqliteTextDescriptor, n as SqliteBigintDescriptor, o as SqliteIntegerDescriptor, r as SqliteBigintNumberDescriptor, s as SqliteJsonDescriptor } from "./codecs-BQWqLgCl-CdB8t7HI.mjs";
+import { t as AdaptedSqliteCodecDescriptor } from "./codec-descriptor-DuW-d9ef-BBRBN0Ri.mjs";
+import "./codec-descriptor-3oN7rtrW-Cc_u7U5-.mjs";
+import { a as SqliteBlobDescriptor, c as SqliteIntegerDescriptor, d as SqliteTextDescriptor, i as SqliteBigintNumberDescriptor, l as SqliteJsonDescriptor, r as SqliteBigintDescriptor, s as SqliteDatetimeDescriptor, u as SqliteRealDescriptor } from "./codecs-BJYruC-a-BKDGae3k.mjs";
 import { ExtractCodecTypes } from "@prisma/orm-family-sql/relational-core/ast";
-//#region ../../../3-targets/3-targets/sqlite/dist/codec-types-D7uWRvQ1.d.mts
+//#region ../../../3-targets/sqlite/1-target/dist/codec-types-COh75Bop.d.mts
 //#region src/exports/codec-types.d.ts
 declare const codecDescriptorMap: {
   readonly char: AdaptedSqliteCodecDescriptor<import("@prisma/orm-family-sql/relational-core/ast").SqlCharDescriptor>;
@@ -17,9 +17,10 @@ declare const codecDescriptorMap: {
   readonly json: SqliteJsonDescriptor;
   readonly bigint: SqliteBigintDescriptor;
   readonly bigintnumber: SqliteBigintNumberDescriptor;
+  readonly raw: AdaptedSqliteCodecDescriptor<import("@prisma/orm-family-sql/relational-core/ast").SqlRawDescriptor>;
 };
 type Resolve<T> = { readonly [K in keyof T]: { readonly [P in keyof T[K]]: T[K][P]; }; };
 type CodecTypes = Resolve<ExtractCodecTypes<typeof codecDescriptorMap>>;
 //#endregion
 export { CodecTypes as t };
-//# sourceMappingURL=codec-types-D7uWRvQ1-DPnvquS8.d.mts.map
+//# sourceMappingURL=codec-types-COh75Bop-CUehAexc.d.mts.map

package/dist/codec-types-COh75Bop-CUehAexc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-COh75Bop-CUehAexc.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/codec-types-COh75Bop.d.mts"],"mappings":";;;;;;cAKc;WACH,MAAM,yEAAyE;WAC/E,SAAS,yEAAyE;WAClF,KAAK,yEAAyE;WAC9E,OAAO,yEAAyE;WAChF,MAAM;WACN,SAAS;WACT,MAAM;WACN,MAAM;WACN,UAAU;WACV,MAAM;WACN,QAAQ;WACR,cAAc;WACd,KAAK,yEAAyE;;KAEpF,QAAQ,iBAAiB,WAAW,gBAAgB,WAAW,EAAE,KAAK,EAAE,GAAG;KAC3E,aAAa,QAAQ,yBAAyB"}

package/dist/codec-types-ELHfd82J.d.mts

@@ -0,0 +1,2 @@
+import "./codecs-BJYruC-a-BKDGae3k.mjs";
+import "./codec-types-COh75Bop-CUehAexc.mjs";

package/dist/codec-types-PONhVn74.d.mts

@@ -0,0 +1 @@
+import "./codec-types-ELHfd82J.mjs";

package/dist/{codecs-BQWqLgCl-CdB8t7HI.d.mts → codecs-BJYruC-a-BKDGae3k.d.mts}

@@ -1,10 +1,11 @@
-import { i as SqliteCodecDescriptorRegistry, r as SqliteCodecDescriptor } from "./codec-descriptor-BcgD9f3L-yDi5nh_k.mjs";
-import { a as SQLITE_INTEGER_CODEC_ID, c as SQLITE_TEXT_CODEC_ID, i as SQLITE_DATETIME_CODEC_ID, n as SQLITE_BIGINT_NUMBER_CODEC_ID, o as SQLITE_JSON_CODEC_ID, r as SQLITE_BLOB_CODEC_ID, s as SQLITE_REAL_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-CzeDyMWW-BZAcI50I.mjs";
+import { i as SqliteCodecDescriptorRegistry, n as AnySqliteCodecDescriptor, r as SqliteCodecDescriptor } from "./codec-descriptor-DuW-d9ef-BBRBN0Ri.mjs";
+import { a as SQLITE_INTEGER_CODEC_ID, c as SQLITE_TEXT_CODEC_ID, i as SQLITE_DATETIME_CODEC_ID, n as SQLITE_BIGINT_NUMBER_CODEC_ID, o as SQLITE_JSON_CODEC_ID, r as SQLITE_BLOB_CODEC_ID, s as SQLITE_REAL_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-DuJYssXV-BPKbFNRL.mjs";
 import { ProjectionExpr } from "@prisma/orm-family-sql/relational-core/ast";
-import { CodecCallContext, CodecImpl, CodecInstanceContext } from "@prisma/orm-framework/components/codec";
+import { CodecCallContext, CodecImpl, CodecInstanceContext, CodecRegistry, DataTypeValue } from "@prisma/orm-framework/components/codec";
+import { ComponentMetadata } from "@prisma/orm-framework/components/components";
 import { JsonValue } from "@prisma/orm-framework/contract/types";
 import { CodecDescriptorRegistry } from "@prisma/orm-family-sql/relational-core/query-lane-context";
-//#region ../../../3-targets/3-targets/sqlite/dist/codecs-BQWqLgCl.d.mts
+//#region ../../../3-targets/sqlite/1-target/dist/codecs-BJYruC-a.d.mts
 //#region src/core/codec-helpers.d.ts
 /**
  * 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.
@@ -13,6 +14,18 @@ type JsonValue$1 = string | number | boolean | null | {
   readonly [key: string]: JsonValue$1;
 } | readonly JsonValue$1[];
 //#endregion
+//#region src/core/codec-registry.d.ts
+type CodecContributor = Pick<ComponentMetadata, 'types'>;
+type SqliteCodecRegistry = CodecRegistry & SqliteCodecDescriptorRegistry;
+declare function assembleSqliteCodecRegistry(target: CodecContributor, extensions: ReadonlyArray<CodecContributor>): SqliteCodecRegistry;
+declare function createSqliteCodecRegistryWithBuiltins(codecDescriptors?: readonly AnySqliteCodecDescriptor[]): SqliteCodecRegistry;
+/**
+ * Build a coherent SQLite codec registry populated with built-in descriptors only.
+ *
+ * The returned registry supports both ordinary codec materialization and SQLite target behavior. Stack-composed paths build the same combined registry from target, full adapter, and ordered extension contributions.
+ */
+declare function createSqliteBuiltinCodecLookup(): SqliteCodecRegistry;
+//#endregion
 //#region src/core/codecs.d.ts
 /**
  * Re-applies SQLite's JSON subtype to a document-valued expression.
@@ -36,98 +49,106 @@ type JsonValue$1 = string | number | boolean | null | {
  */
 declare const jsonDocumentRetag: (expression: ProjectionExpr) => ProjectionExpr;
 declare class SqliteTextCodec extends CodecImpl<typeof SQLITE_TEXT_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
-  encode(value: string, _ctx: CodecCallContext): Promise<string>;
-  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
-  encodeJson(value: string): JsonValue;
-  decodeJson(json: JsonValue): string;
+  toWire(value: string, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string, _ctx: CodecCallContext): Promise<string>;
+  fromDataTypeValue(value: DataTypeValue<string>): string;
+  toDataTypeValue(input: string): DataTypeValue;
 }
 declare class SqliteTextDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/text@1";
   readonly traits: readonly ["equality", "order", "textual"];
-  readonly targetTypes: readonly ["text"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteTextCodec;
 }
 declare const sqliteTextColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteTextCodec, undefined>;
-declare class SqliteIntegerCodec extends CodecImpl<typeof SQLITE_INTEGER_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
-  encode(value: number, _ctx: CodecCallContext): Promise<number>;
-  decode(wire: number, _ctx: CodecCallContext): Promise<number>;
-  encodeJson(value: number): JsonValue;
-  decodeJson(json: JsonValue): number;
+declare class SqliteIntegerCodec extends CodecImpl<typeof SQLITE_INTEGER_CODEC_ID, readonly ['equality', 'order', 'numeric'], number | string, number> {
+  toWire(value: number, _ctx: CodecCallContext): Promise<number>;
+  fromWire(wire: number | string, _ctx: CodecCallContext): Promise<number>;
+  fromDataTypeValue(value: DataTypeValue<string>): number;
+  toDataTypeValue(input: number): DataTypeValue;
 }
 declare class SqliteIntegerDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/integer@1";
   readonly traits: readonly ["equality", "order", "numeric"];
-  readonly targetTypes: readonly ["integer"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteIntegerCodec;
 }
 declare const sqliteIntegerColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteIntegerCodec, undefined>;
-declare class SqliteRealCodec extends CodecImpl<typeof SQLITE_REAL_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
-  encode(value: number, _ctx: CodecCallContext): Promise<number>;
-  decode(wire: number, _ctx: CodecCallContext): Promise<number>;
-  encodeJson(value: number): JsonValue;
-  decodeJson(json: JsonValue): number;
+declare class SqliteRealCodec extends CodecImpl<typeof SQLITE_REAL_CODEC_ID, readonly ['equality', 'order', 'numeric'], number | string, number> {
+  toWire(value: number, _ctx: CodecCallContext): Promise<number>;
+  fromWire(wire: number | string, _ctx: CodecCallContext): Promise<number>;
+  fromDataTypeValue(value: DataTypeValue<JsonValue>): number;
+  toDataTypeValue(input: number): DataTypeValue;
 }
 declare class SqliteRealDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/real@1";
   readonly traits: readonly ["equality", "order", "numeric"];
-  readonly targetTypes: readonly ["real"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteRealCodec;
 }
 declare const sqliteRealColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteRealCodec, undefined>;
-declare class SqliteBlobCodec extends CodecImpl<typeof SQLITE_BLOB_CODEC_ID, readonly ['equality'], Uint8Array, Uint8Array> {
-  encode(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array>;
-  decode(wire: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array>;
-  encodeJson(value: Uint8Array): JsonValue;
-  decodeJson(json: JsonValue): Uint8Array;
+declare class SqliteBlobCodec extends CodecImpl<typeof SQLITE_BLOB_CODEC_ID, readonly ['equality'], Uint8Array | readonly string[], Uint8Array> {
+  toWire(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array>;
+  /** A row carries the blob's bytes; an include carries the array of their hex text that its projection writes, because SQLite's JSON functions refuse a blob. Anything else a BLOB column holds is refused. */
+  fromWire(wire: Uint8Array | readonly string[], _ctx: CodecCallContext): Promise<Uint8Array>;
+  fromDataTypeValue(value: DataTypeValue<string>): Uint8Array;
+  toDataTypeValue(input: Uint8Array): DataTypeValue;
 }
 declare class SqliteBlobDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/blob@1";
   readonly traits: readonly ["equality"];
-  readonly targetTypes: readonly ["blob"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteBlobCodec;
 }
 declare const sqliteBlobColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteBlobCodec, undefined>;
 declare class SqliteDatetimeCodec extends CodecImpl<typeof SQLITE_DATETIME_CODEC_ID, readonly ['equality', 'order'], string, Date> {
-  private parseDate;
-  encode(value: Date, _ctx: CodecCallContext): Promise<string>;
-  decode(wire: string, _ctx: CodecCallContext): Promise<Date>;
-  encodeJson(value: Date): JsonValue;
-  decodeJson(json: JsonValue): Date;
+  toWire(value: Date, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string | number, _ctx: CodecCallContext): Promise<Date>;
+  fromDataTypeValue(value: DataTypeValue<string>): Date;
+  toDataTypeValue(input: Date): DataTypeValue;
 }
 declare class SqliteDatetimeDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/datetime@1";
   readonly traits: readonly ["equality", "order"];
-  readonly targetTypes: readonly ["text"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteDatetimeCodec;
 }
 declare const sqliteDatetimeColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteDatetimeCodec, undefined>;
 declare class SqliteJsonCodec extends CodecImpl<typeof SQLITE_JSON_CODEC_ID, readonly ['equality'], string | JsonValue, JsonValue> {
-  encode(value: JsonValue, _ctx: CodecCallContext): Promise<string>;
-  decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue>;
-  encodeJson(value: JsonValue): JsonValue;
-  decodeJson(json: JsonValue): JsonValue;
+  toWire(value: JsonValue, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue>;
+  fromDataTypeValue(value: DataTypeValue<string>): JsonValue;
+  toDataTypeValue(input: JsonValue): DataTypeValue;
 }
+/**
+ * The column stores the document's JSON text and the stored form is that text, so the stored
+ * value is projected as it is: a string the enclosing JSON constructor embeds as a string.
+ */
 declare class SqliteJsonDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/json@1";
   readonly traits: readonly ["equality"];
-  readonly targetTypes: readonly ["text"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteJsonCodec;
 }
 declare const sqliteJsonColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteJsonCodec, undefined>;
 declare class SqliteBigintCodec extends CodecImpl<typeof SQLITE_BIGINT_CODEC_ID, readonly ['equality', 'order', 'numeric'], number | bigint | string, bigint> {
-  encode(value: bigint, _ctx: CodecCallContext): Promise<number | bigint>;
+  toWire(value: bigint, _ctx: CodecCallContext): Promise<number | bigint>;
   /**
    * The wire value is text wherever the value could outrun a JS number: an
    * aggregate SQLite computes leaves the database through the descriptor's cast
@@ -136,16 +157,17 @@ declare class SqliteBigintCodec extends CodecImpl<typeof SQLITE_BIGINT_CODEC_ID,
    * integer — past ±(2^53 − 1) it has already rounded, and converting it would
    * mint a spuriously-exact `bigint` that need not equal the stored value.
    */
-  decode(wire: number | bigint | string, _ctx: CodecCallContext): Promise<bigint>;
-  encodeJson(value: bigint): JsonValue;
-  decodeJson(json: JsonValue): bigint;
+  fromWire(wire: number | bigint | string, _ctx: CodecCallContext): Promise<bigint>;
+  fromDataTypeValue(value: DataTypeValue<string>): bigint;
+  toDataTypeValue(input: bigint): DataTypeValue;
 }
 declare class SqliteBigintDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/bigint@1";
   readonly traits: readonly ["equality", "order", "numeric"];
-  readonly targetTypes: readonly ["integer"];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
+  renderValueLiteral(value: JsonValue): string | undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteBigintCodec;
 }
 declare const sqliteBigintColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteBigintCodec, undefined>;
@@ -153,33 +175,35 @@ declare const sqliteBigintColumn: () => import("@prisma/orm-framework/components
  * A SQLite INTEGER decoded as a JS `number`, for columns whose values stay
  * within the safe integer range ±(2^53 − 1). Both directions guard rather than
  * round: decode (wire and JSON) and encode throw a structured error on
- * out-of-range or non-integral input. The canonical JSON is a JSON number —
- * the deliberate exception to the decimal-text rule for 64-bit integers, and
- * the codec's purpose. The descriptor claims no target type, so `integer` in
- * type position keeps its current codecs.
+ * out-of-range or non-integral input. The canonical JSON is the decimal text
+ * `sqlite/integer` carries, which every codec of that data type shares.
  */
 declare class SqliteBigintNumberCodec extends CodecImpl<typeof SQLITE_BIGINT_NUMBER_CODEC_ID, readonly ['equality', 'order', 'numeric'], number | bigint | string, number> {
-  encode(value: number, _ctx: CodecCallContext): Promise<number>;
+  toWire(value: number, _ctx: CodecCallContext): Promise<number>;
   /**
    * The driver hands an INTEGER over as a `number` or, in safe-integer mode, a
    * `bigint`; a bigint (or decimal text) is range-checked exactly before any
    * conversion to `number`, so an out-of-range value throws rather than rounds.
    */
-  decode(wire: number | bigint | string, _ctx: CodecCallContext): Promise<number>;
-  encodeJson(value: number): JsonValue;
-  decodeJson(json: JsonValue): number;
+  fromWire(wire: number | bigint | string, _ctx: CodecCallContext): Promise<number>;
+  fromDataTypeValue(value: DataTypeValue<string>): number;
+  toDataTypeValue(input: number): DataTypeValue;
 }
 declare class SqliteBigintNumberDescriptor extends SqliteCodecDescriptor<void> {
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
+  readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "sqlite/bigintnumber@1";
   readonly traits: readonly ["equality", "order", "numeric"];
-  readonly targetTypes: readonly [];
-  readonly paramsSchema: import("@standard-schema/spec").StandardSchemaV1<void, void>;
+  readonly paramsSchema: undefined;
   renderValueLiteral(value: JsonValue): string | undefined;
   factory(): (ctx: CodecInstanceContext) => SqliteBigintNumberCodec;
 }
 declare const sqliteBigintNumberColumn: () => import("@prisma/orm-framework/components/codec").ColumnSpec<SqliteBigintNumberCodec, undefined>;
 //#endregion
+//#region src/core/datetime-text.d.ts
+/** The SQLite expression for the current instant, as the text `encodeSqliteDatetime` writes. */
+declare const SQLITE_NOW_EXPRESSION = "strftime('%Y-%m-%dT%H:%M:%fZ','now')";
+//#endregion
 //#region src/core/registry.d.ts
 /**
  * Registry of every codec descriptor shipped by `@internal/target-sqlite`.
@@ -189,5 +213,5 @@ declare const sqliteBigintNumberColumn: () => import("@prisma/orm-framework/comp
 declare const sqliteCodecRegistry: CodecDescriptorRegistry;
 declare const sqliteCodecDescriptorRegistry: SqliteCodecDescriptorRegistry;
 //#endregion
-export { sqliteIntegerColumn as _, SqliteDatetimeDescriptor as a, sqliteTextColumn as b, SqliteRealDescriptor as c, sqliteBigintColumn as d, sqliteBigintNumberColumn as f, sqliteDatetimeColumn as g, sqliteCodecRegistry as h, SqliteBlobDescriptor as i, SqliteTextDescriptor as l, sqliteCodecDescriptorRegistry as m, SqliteBigintDescriptor as n, SqliteIntegerDescriptor as o, sqliteBlobColumn as p, SqliteBigintNumberDescriptor as r, SqliteJsonDescriptor as s, JsonValue$1 as t, jsonDocumentRetag as u, sqliteJsonColumn as v, sqliteRealColumn as y };
-//# sourceMappingURL=codecs-BQWqLgCl-CdB8t7HI.d.mts.map
+export { sqliteJsonColumn as C, sqliteIntegerColumn as S, sqliteTextColumn as T, sqliteBigintNumberColumn as _, SqliteBlobDescriptor as a, sqliteCodecRegistry as b, SqliteIntegerDescriptor as c, SqliteTextDescriptor as d, assembleSqliteCodecRegistry as f, sqliteBigintColumn as g, jsonDocumentRetag as h, SqliteBigintNumberDescriptor as i, SqliteJsonDescriptor as l, createSqliteCodecRegistryWithBuiltins as m, SQLITE_NOW_EXPRESSION as n, SqliteCodecRegistry as o, createSqliteBuiltinCodecLookup as p, SqliteBigintDescriptor as r, SqliteDatetimeDescriptor as s, JsonValue$1 as t, SqliteRealDescriptor as u, sqliteBlobColumn as v, sqliteRealColumn as w, sqliteDatetimeColumn as x, sqliteCodecDescriptorRegistry as y };
+//# sourceMappingURL=codecs-BJYruC-a-BKDGae3k.d.mts.map

package/dist/codecs-BJYruC-a-BKDGae3k.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-BJYruC-a-BKDGae3k.d.mts","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/codecs-BJYruC-a.d.mts"],"mappings":"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"}

package/dist/codecs-Dn0xoCuf.d.mts

@@ -0,0 +1 @@
+import "./codecs-BJYruC-a-BKDGae3k.mjs";

package/dist/codecs-g-YI3BtK.mjs

@@ -0,0 +1,49 @@
+import { n as buildSqliteCodecDescriptorRegistry } from "./codec-descriptor-DRmF-crq-BALI5Jtz.mjs";
+import { t as codecDescriptors } from "./codecs-yZoH21Yj-lQXtGlEq.mjs";
+import { extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { buildCodecDescriptorRegistry } from "@prisma/orm-family-sql/relational-core/codec-descriptor-registry";
+//#region ../../../3-targets/sqlite/1-target/dist/codecs.mjs
+/**
+* Registry of every codec descriptor shipped by `@internal/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.
+*/
+const sqliteCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
+const sqliteCodecDescriptorRegistry = buildSqliteCodecDescriptorRegistry(codecDescriptors);
+function descriptorsFrom(contributors) {
+	return contributors.flatMap((contributor) => contributor.types?.codecTypes?.codecDescriptors ?? []);
+}
+function buildSqliteCodecRegistry(descriptors) {
+	const descriptorRegistry = buildSqliteCodecDescriptorRegistry(descriptors);
+	const registry = {
+		...extractCodecLookup([{
+			id: "sqlite-codecs",
+			types: { codecTypes: { codecDescriptors: Array.from(descriptorRegistry.values()) } }
+		}]),
+		descriptorFor: (codecId) => descriptorRegistry.descriptorFor(codecId),
+		values: () => descriptorRegistry.values()
+	};
+	return Object.freeze(registry);
+}
+function assembleSqliteCodecRegistry(target, extensions) {
+	return buildSqliteCodecRegistry([
+		...descriptorsFrom([target]),
+		...sqliteCodecDescriptorRegistry.values(),
+		...descriptorsFrom(extensions)
+	]);
+}
+function createSqliteCodecRegistryWithBuiltins(codecDescriptors = []) {
+	return buildSqliteCodecRegistry([...sqliteCodecDescriptorRegistry.values(), ...codecDescriptors]);
+}
+/**
+* Build a coherent SQLite codec registry populated with built-in descriptors only.
+*
+* The returned registry supports both ordinary codec materialization and SQLite target behavior. Stack-composed paths build the same combined registry from target, full adapter, and ordered extension contributions.
+*/
+function createSqliteBuiltinCodecLookup() {
+	return createSqliteCodecRegistryWithBuiltins();
+}
+//#endregion
+export { sqliteCodecRegistry as a, sqliteCodecDescriptorRegistry as i, createSqliteBuiltinCodecLookup as n, createSqliteCodecRegistryWithBuiltins as r, assembleSqliteCodecRegistry as t };
+
+//# sourceMappingURL=codecs-g-YI3BtK.mjs.map

package/dist/codecs-g-YI3BtK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-g-YI3BtK.mjs","names":[],"sources":["../../../../3-targets/sqlite/1-target/dist/codecs.mjs"],"sourcesContent":["import { n as buildSqliteCodecDescriptorRegistry } from \"./codec-descriptor-DRmF-crq.mjs\";\nimport { a as sqliteBigintNumberColumn, c as sqliteIntegerColumn, d as sqliteTextColumn, i as sqliteBigintColumn, l as sqliteJsonColumn, o as sqliteBlobColumn, r as jsonDocumentRetag, s as sqliteDatetimeColumn, t as codecDescriptors, u as sqliteRealColumn } from \"./codecs-yZoH21Yj.mjs\";\nimport { n as SQLITE_NOW_EXPRESSION } from \"./datetime-text-Bniwehv-.mjs\";\nimport { extractCodecLookup } from \"@internal/framework-components/control\";\nimport { buildCodecDescriptorRegistry } from \"@internal/sql-relational-core/codec-descriptor-registry\";\n//#region src/core/registry.ts\n/**\n* Registry of every codec descriptor shipped by `@internal/target-sqlite`.\n*\n* 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.\n*/\nconst sqliteCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);\nconst sqliteCodecDescriptorRegistry = buildSqliteCodecDescriptorRegistry(codecDescriptors);\n//#endregion\n//#region src/core/codec-registry.ts\nfunction descriptorsFrom(contributors) {\n\treturn contributors.flatMap((contributor) => contributor.types?.codecTypes?.codecDescriptors ?? []);\n}\nfunction buildSqliteCodecRegistry(descriptors) {\n\tconst descriptorRegistry = buildSqliteCodecDescriptorRegistry(descriptors);\n\tconst registry = {\n\t\t...extractCodecLookup([{\n\t\t\tid: \"sqlite-codecs\",\n\t\t\ttypes: { codecTypes: { codecDescriptors: Array.from(descriptorRegistry.values()) } }\n\t\t}]),\n\t\tdescriptorFor: (codecId) => descriptorRegistry.descriptorFor(codecId),\n\t\tvalues: () => descriptorRegistry.values()\n\t};\n\treturn Object.freeze(registry);\n}\nfunction assembleSqliteCodecRegistry(target, extensions) {\n\treturn buildSqliteCodecRegistry([\n\t\t...descriptorsFrom([target]),\n\t\t...sqliteCodecDescriptorRegistry.values(),\n\t\t...descriptorsFrom(extensions)\n\t]);\n}\nfunction createSqliteCodecRegistryWithBuiltins(codecDescriptors = []) {\n\treturn buildSqliteCodecRegistry([...sqliteCodecDescriptorRegistry.values(), ...codecDescriptors]);\n}\n/**\n* Build a coherent SQLite codec registry populated with built-in descriptors only.\n*\n* The returned registry supports both ordinary codec materialization and SQLite target behavior. Stack-composed paths build the same combined registry from target, full adapter, and ordered extension contributions.\n*/\nfunction createSqliteBuiltinCodecLookup() {\n\treturn createSqliteCodecRegistryWithBuiltins();\n}\n//#endregion\nexport { SQLITE_NOW_EXPRESSION, assembleSqliteCodecRegistry, createSqliteBuiltinCodecLookup, createSqliteCodecRegistryWithBuiltins, jsonDocumentRetag, sqliteBigintColumn, sqliteBigintNumberColumn, sqliteBlobColumn, sqliteCodecDescriptorRegistry, sqliteCodecRegistry, sqliteDatetimeColumn, sqliteIntegerColumn, sqliteJsonColumn, sqliteRealColumn, sqliteTextColumn };\n\n//# sourceMappingURL=codecs.mjs.map"],"mappings":";;;;;;;;;;AAWA,MAAM,sBAAsB,6BAA6B,gBAAgB;AACzE,MAAM,gCAAgC,mCAAmC,gBAAgB;AAGzF,SAAS,gBAAgB,cAAc;CACtC,OAAO,aAAa,SAAS,gBAAgB,YAAY,OAAO,YAAY,oBAAoB,CAAC,CAAC;AACnG;AACA,SAAS,yBAAyB,aAAa;CAC9C,MAAM,qBAAqB,mCAAmC,WAAW;CACzE,MAAM,WAAW;EAChB,GAAG,mBAAmB,CAAC;GACtB,IAAI;GACJ,OAAO,EAAE,YAAY,EAAE,kBAAkB,MAAM,KAAK,mBAAmB,OAAO,CAAC,EAAE,EAAE;EACpF,CAAC,CAAC;EACF,gBAAgB,YAAY,mBAAmB,cAAc,OAAO;EACpE,cAAc,mBAAmB,OAAO;CACzC;CACA,OAAO,OAAO,OAAO,QAAQ;AAC9B;AACA,SAAS,4BAA4B,QAAQ,YAAY;CACxD,OAAO,yBAAyB;EAC/B,GAAG,gBAAgB,CAAC,MAAM,CAAC;EAC3B,GAAG,8BAA8B,OAAO;EACxC,GAAG,gBAAgB,UAAU;CAC9B,CAAC;AACF;AACA,SAAS,sCAAsC,mBAAmB,CAAC,GAAG;CACrE,OAAO,yBAAyB,CAAC,GAAG,8BAA8B,OAAO,GAAG,GAAG,gBAAgB,CAAC;AACjG;;;;;;AAMA,SAAS,iCAAiC;CACzC,OAAO,sCAAsC;AAC9C"}