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

package/README.md

@@ -42,6 +42,10 @@ export const contract = defineContract()
 
 Pack refs are pure JSON-friendly objects that make TypeScript contract authoring work in both emit and no-emit workflows without requiring separate manifest files.
 
+## Codec descriptor authoring
+
+SQLite-bound codecs use the public `SqliteCodecDescriptor` protocol, `sqliteCodec(...)` adapter, and `defineSqliteCodecs(...)` tuple helper exported from `@prisma-next/target-sqlite/codec-descriptor`. See the [codec authoring guide](../../../../docs/reference/codec-authoring-guide.md#target-owned-sql-codec-descriptors) for subclassing, generic adaptation, stack contribution, structural validation, SQLite's scalar-only contract, and the current renderer transition.
+
 ## Architecture
 
 This package provides a runtime entry point for the SQLite target. All declarative fields (version, capabilities) are defined directly on the descriptor. The `./pack` entry point provides a pure pack ref for contract authoring.

package/dist/codec-descriptor-2XsVwVp_.d.mts

@@ -0,0 +1,30 @@
+import { ProjectionExpr } from "@prisma-next/sql-relational-core/ast";
+import { AnyCodecDescriptor, CodecDescriptor, CodecDescriptorImpl, CodecRef } from "@prisma-next/framework-components/codec";
+//#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): 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): ProjectionExpr;
+  private validateParams;
+}
+type DescriptorParams<D extends AnyCodecDescriptor> = D extends CodecDescriptor<infer P> ? P : never;
+interface SqliteCodecOptions<P> {
+  readonly jsonProjection: (expression: ProjectionExpr, params: P) => ProjectionExpr;
+}
+type AdaptedSqliteCodecDescriptor<D extends AnyCodecDescriptor> = Pick<D, keyof CodecDescriptor<DescriptorParams<D>>> & Pick<AnySqliteCodecDescriptor, 'descriptorKind' | 'projectJson'>;
+declare function sqliteCodec<D extends AnyCodecDescriptor>(descriptor: D, options: SqliteCodecOptions<DescriptorParams<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-2XsVwVp_.d.mts.map

package/dist/codec-descriptor-2XsVwVp_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-descriptor-2XsVwVp_.d.mts","names":[],"sources":["../src/core/codec-descriptor.ts"],"mappings":";;;cAgBM;UAEW,iCAAiC;WACvC,uBAAuB;EAChC,YAAY,YAAY,gBAAgB,KAAK,WAAW;;uBAGpC,sBAAsB,kBAClC,oBAAoB,cACjB;WAEF;qBAEU,eAAe,YAAY,gBAAgB,QAAQ,IAAI;EAE1E,YAAY,YAAY,gBAAgB,KAAK,WAAW;UAgBhD;;KAQL,iBAAiB,UAAU,sBAC9B,UAAU,sBAAsB,KAAK;UAEtB,mBAAmB;WACzB,iBAAiB,YAAY,gBAAgB,QAAQ,MAAM;;KAG1D,6BAA6B,UAAU,sBAAsB,KACvE,SACM,gBAAgB,iBAAiB,OAEvC,KAAK;iBAwES,YAAY,UAAU,oBACpC,YAAY,GACZ,SAAS,mBAAmB,iBAAiB,MAC5C,6BAA6B;iBAOhB,yBAAyB,6BAA6B,4BACpE,aAAa,cACZ;iBAIa,wBAAwB,iBAAiB,SAAS;UAgCjD;EACf,cAAc,kBAAkB;EAChC,UAAU,iBAAiB;;iBAoBb,mCACd,aAAa,yBACZ"}

package/dist/codec-descriptor-BlnLtrba.d.mts

@@ -0,0 +1 @@
+import "./codec-descriptor-2XsVwVp_.mjs";

package/dist/codec-descriptor-DuYu6llI.mjs

@@ -0,0 +1,111 @@
+import { CodecDescriptorImpl, validateCodecTypeParams } from "@prisma-next/framework-components/codec";
+import { blindCast } from "@prisma-next/utils/casts";
+import { structuredError } from "@prisma-next/utils/structured-error";
+//#region src/core/codec-descriptor.ts
+const SQLITE_CODEC_DESCRIPTOR_KIND = "sqlite-codec";
+var SqliteCodecDescriptor = class extends CodecDescriptorImpl {
+	descriptorKind = SQLITE_CODEC_DESCRIPTOR_KIND;
+	projectJson(expression, ref) {
+		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));
+	}
+	validateParams(ref) {
+		return blindCast(validateCodecTypeParams(this, ref));
+	}
+};
+var SqliteCodecDescriptorAdapter = class extends SqliteCodecDescriptor {
+	descriptor;
+	options;
+	codecId;
+	traits;
+	targetTypes;
+	paramsSchema;
+	metaFor;
+	renderOutputType;
+	renderInputType;
+	renderValueLiteral;
+	constructor(descriptor, options) {
+		super();
+		this.descriptor = descriptor;
+		this.options = options;
+		this.codecId = descriptor.codecId;
+		this.traits = descriptor.traits;
+		this.targetTypes = descriptor.targetTypes;
+		this.paramsSchema = descriptor.paramsSchema;
+		if (descriptor.meta !== void 0) Object.defineProperty(this, "meta", {
+			value: descriptor.meta,
+			enumerable: true
+		});
+		const metaFor = descriptor.metaFor;
+		if (metaFor !== void 0) this.metaFor = (params) => metaFor.call(descriptor, 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;
+	}
+	factory = (params) => this.descriptor.factory(params);
+	jsonProjection(expression, params) {
+		return this.options.jsonProjection(expression, params);
+	}
+};
+function sqliteCodec(descriptor, options) {
+	return blindCast(new SqliteCodecDescriptorAdapter(descriptor, options));
+}
+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";
+}
+function isObjectLike(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+var SqliteCodecDescriptorRegistryImpl = class {
+	#descriptors;
+	constructor(descriptors) {
+		this.#descriptors = descriptors;
+		Object.freeze(this);
+	}
+	descriptorFor(codecId) {
+		return this.#descriptors.get(codecId);
+	}
+	*values() {
+		yield* this.#descriptors.values();
+	}
+};
+function buildSqliteCodecDescriptorRegistry(descriptors) {
+	const byId = /* @__PURE__ */ new Map();
+	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) {
+	return typeof value === "object" && value !== null && "codecId" in value && typeof value.codecId === "string" ? value.codecId : "<unknown>";
+}
+//#endregion
+export { sqliteCodec as a, isSqliteCodecDescriptor as i, buildSqliteCodecDescriptorRegistry as n, defineSqliteCodecs as r, SqliteCodecDescriptor as t };
+
+//# sourceMappingURL=codec-descriptor-DuYu6llI.mjs.map

package/dist/codec-descriptor-DuYu6llI.mjs.map

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

package/dist/codec-descriptor.d.mts

@@ -0,0 +1,3 @@
+import { a as SqliteCodecOptions, c as isSqliteCodecDescriptor, i as SqliteCodecDescriptorRegistry, l as sqliteCodec, n as AnySqliteCodecDescriptor, o as buildSqliteCodecDescriptorRegistry, r as SqliteCodecDescriptor, s as defineSqliteCodecs, t as AdaptedSqliteCodecDescriptor } from "./codec-descriptor-2XsVwVp_.mjs";
+import "./codec-descriptor-BlnLtrba.mjs";
+export { type AdaptedSqliteCodecDescriptor, type AnySqliteCodecDescriptor, SqliteCodecDescriptor, type SqliteCodecDescriptorRegistry, type SqliteCodecOptions, buildSqliteCodecDescriptorRegistry, defineSqliteCodecs, isSqliteCodecDescriptor, sqliteCodec };

package/dist/codec-descriptor.mjs

@@ -0,0 +1,2 @@
+import { a as sqliteCodec, i as isSqliteCodecDescriptor, n as buildSqliteCodecDescriptorRegistry, r as defineSqliteCodecs, t as SqliteCodecDescriptor } from "./codec-descriptor-DuYu6llI.mjs";
+export { SqliteCodecDescriptor, buildSqliteCodecDescriptorRegistry, defineSqliteCodecs, isSqliteCodecDescriptor, sqliteCodec };

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

@@ -0,0 +1,23 @@
+import { t as AdaptedSqliteCodecDescriptor } from "./codec-descriptor-2XsVwVp_.mjs";
+import "./codec-descriptor-BlnLtrba.mjs";
+import { a as SqliteDatetimeDescriptor, c as SqliteRealDescriptor, i as SqliteBlobDescriptor, l as SqliteTextDescriptor, o as SqliteIntegerDescriptor, r as SqliteBigintDescriptor, s as SqliteJsonDescriptor } from "./codecs-D7gJOOpT.mjs";
+import { ExtractCodecTypes } from "@prisma-next/sql-relational-core/ast";
+//#region src/exports/codec-types.d.ts
+declare const codecDescriptorMap: {
+  readonly char: AdaptedSqliteCodecDescriptor<import("@prisma-next/sql-relational-core/ast").SqlCharDescriptor>;
+  readonly varchar: AdaptedSqliteCodecDescriptor<import("@prisma-next/sql-relational-core/ast").SqlVarcharDescriptor>;
+  readonly int: AdaptedSqliteCodecDescriptor<import("@prisma-next/sql-relational-core/ast").SqlIntDescriptor>;
+  readonly float: AdaptedSqliteCodecDescriptor<import("@prisma-next/sql-relational-core/ast").SqlFloatDescriptor>;
+  readonly text: SqliteTextDescriptor;
+  readonly integer: SqliteIntegerDescriptor;
+  readonly real: SqliteRealDescriptor;
+  readonly blob: SqliteBlobDescriptor;
+  readonly datetime: SqliteDatetimeDescriptor;
+  readonly json: SqliteJsonDescriptor;
+  readonly bigint: SqliteBigintDescriptor;
+};
+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-BjeYtMEc.d.mts.map

package/dist/codec-types-BjeYtMEc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-BjeYtMEc.d.mts","names":[],"sources":["../src/exports/codec-types.ts"],"mappings":";;;;;cAsBM;iBAAA;;;;;;;;;;;;KAcD,QAAQ,iBAAiB,WAAW,gBAAgB,WAAW,EAAE,KAAK,EAAE,GAAG;KAEpE,aAAa,QAAQ,yBAAyB"}

package/dist/codec-types.d.mts

@@ -1,3 +1,3 @@
-import { g as JsonValue } from "./codecs-DGgo--O0.mjs";
-import { t as CodecTypes } from "./codec-types-CcFkbJ3o.mjs";
+import { _ as JsonValue } from "./codecs-D7gJOOpT.mjs";
+import { t as CodecTypes } from "./codec-types-BjeYtMEc.mjs";
 export { CodecTypes, type JsonValue };

package/dist/codec-types.mjs

@@ -1,2 +1 @@
-import "@prisma-next/sql-relational-core/ast";
 export {};

package/dist/{codecs-DGgo--O0.d.mts → codecs-D7gJOOpT.d.mts}

@@ -1,5 +1,7 @@
+import { i as SqliteCodecDescriptorRegistry, r as SqliteCodecDescriptor } from "./codec-descriptor-2XsVwVp_.mjs";
 import { a as SQLITE_JSON_CODEC_ID, i as SQLITE_INTEGER_CODEC_ID, n as SQLITE_BLOB_CODEC_ID, o as SQLITE_REAL_CODEC_ID, r as SQLITE_DATETIME_CODEC_ID, s as SQLITE_TEXT_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-Dof8fZfe.mjs";
-import { CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
+import { ProjectionExpr } from "@prisma-next/sql-relational-core/ast";
+import { CodecCallContext, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
 import { JsonValue } from "@prisma-next/contract/types";
 import { CodecDescriptorRegistry } from "@prisma-next/sql-relational-core/query-lane-context";
 //#region src/core/codec-helpers.d.ts
@@ -17,7 +19,8 @@ declare class SqliteTextCodec extends CodecImpl<typeof SQLITE_TEXT_CODEC_ID, rea
   encodeJson(value: string): JsonValue;
   decodeJson(json: JsonValue): string;
 }
-declare class SqliteTextDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteTextDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/text@1";
   readonly traits: readonly ["equality", "order", "textual"];
   readonly targetTypes: readonly ["text"];
@@ -31,7 +34,8 @@ declare class SqliteIntegerCodec extends CodecImpl<typeof SQLITE_INTEGER_CODEC_I
   encodeJson(value: number): JsonValue;
   decodeJson(json: JsonValue): number;
 }
-declare class SqliteIntegerDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteIntegerDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/integer@1";
   readonly traits: readonly ["equality", "order", "numeric"];
   readonly targetTypes: readonly ["integer"];
@@ -45,7 +49,8 @@ declare class SqliteRealCodec extends CodecImpl<typeof SQLITE_REAL_CODEC_ID, rea
   encodeJson(value: number): JsonValue;
   decodeJson(json: JsonValue): number;
 }
-declare class SqliteRealDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteRealDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/real@1";
   readonly traits: readonly ["equality", "order", "numeric"];
   readonly targetTypes: readonly ["real"];
@@ -59,7 +64,8 @@ declare class SqliteBlobCodec extends CodecImpl<typeof SQLITE_BLOB_CODEC_ID, rea
   encodeJson(value: Uint8Array): JsonValue;
   decodeJson(json: JsonValue): Uint8Array;
 }
-declare class SqliteBlobDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteBlobDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/blob@1";
   readonly traits: readonly ["equality"];
   readonly targetTypes: readonly ["blob"];
@@ -74,7 +80,8 @@ declare class SqliteDatetimeCodec extends CodecImpl<typeof SQLITE_DATETIME_CODEC
   encodeJson(value: Date): JsonValue;
   decodeJson(json: JsonValue): Date;
 }
-declare class SqliteDatetimeDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteDatetimeDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/datetime@1";
   readonly traits: readonly ["equality", "order"];
   readonly targetTypes: readonly ["text"];
@@ -88,7 +95,8 @@ declare class SqliteJsonCodec extends CodecImpl<typeof SQLITE_JSON_CODEC_ID, rea
   encodeJson(value: JsonValue): JsonValue;
   decodeJson(json: JsonValue): JsonValue;
 }
-declare class SqliteJsonDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteJsonDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/json@1";
   readonly traits: readonly ["equality"];
   readonly targetTypes: readonly ["text"];
@@ -102,7 +110,8 @@ declare class SqliteBigintCodec extends CodecImpl<typeof SQLITE_BIGINT_CODEC_ID,
   encodeJson(value: bigint): JsonValue;
   decodeJson(json: JsonValue): bigint;
 }
-declare class SqliteBigintDescriptor extends CodecDescriptorImpl<void> {
+declare class SqliteBigintDescriptor extends SqliteCodecDescriptor<void> {
+  protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly codecId: "sqlite/bigint@1";
   readonly traits: readonly ["equality", "order", "numeric"];
   readonly targetTypes: readonly ["integer"];
@@ -118,6 +127,7 @@ declare const sqliteBigintColumn: () => import("@prisma-next/framework-component
  * 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.
  */
 declare const sqliteCodecRegistry: CodecDescriptorRegistry;
+declare const sqliteCodecDescriptorRegistry: SqliteCodecDescriptorRegistry;
 //#endregion
-export { SqliteIntegerDescriptor as a, SqliteTextDescriptor as c, sqliteDatetimeColumn as d, sqliteIntegerColumn as f, JsonValue$1 as g, sqliteTextColumn as h, SqliteDatetimeDescriptor as i, sqliteBigintColumn as l, sqliteRealColumn as m, SqliteBigintDescriptor as n, SqliteJsonDescriptor as o, sqliteJsonColumn as p, SqliteBlobDescriptor as r, SqliteRealDescriptor as s, sqliteCodecRegistry as t, sqliteBlobColumn as u };
-//# sourceMappingURL=codecs-DGgo--O0.d.mts.map
+export { JsonValue$1 as _, SqliteDatetimeDescriptor as a, SqliteRealDescriptor as c, sqliteBlobColumn as d, sqliteDatetimeColumn as f, sqliteTextColumn as g, sqliteRealColumn as h, SqliteBlobDescriptor as i, SqliteTextDescriptor as l, sqliteJsonColumn as m, sqliteCodecRegistry as n, SqliteIntegerDescriptor as o, sqliteIntegerColumn as p, SqliteBigintDescriptor as r, SqliteJsonDescriptor as s, sqliteCodecDescriptorRegistry as t, sqliteBigintColumn as u };
+//# sourceMappingURL=codecs-D7gJOOpT.d.mts.map

package/dist/codecs-D7gJOOpT.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs-D7gJOOpT.d.mts","names":[],"sources":["../src/core/codec-helpers.ts","../src/core/codecs.ts","../src/core/registry.ts"],"mappings":";;;;;;;;;;KAIY;YAKI,cAAc;aACjB;;;cCkDA,wBAAwB,iBAC5B;EAKD,OAAO,eAAe,MAAM,mBAAmB;EAG/C,OAAO,cAAc,MAAM,mBAAmB;EAGpD,WAAW,gBAAgB;EAG3B,WAAW,MAAM;;cAKN,6BAA6B;YACrB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,0EAAgB,WAAA;cAMhB,2BAA2B,iBAC/B;EAKD,OAAO,eAAe,MAAM,mBAAmB;EAG/C,OAAO,cAAc,MAAM,mBAAmB;EAGpD,WAAW,gBAAgB;EAG3B,WAAW,MAAM;;cAKN,gCAAgC;YACxB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,6EAAmB,WAAA;cAMnB,wBAAwB,iBAC5B;EAKD,OAAO,eAAe,MAAM,mBAAmB;EAG/C,OAAO,cAAc,MAAM,mBAAmB;EAGpD,WAAW,gBAAgB;EAG3B,WAAW,MAAM;;cAKN,6BAA6B;YACrB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,0EAAgB,WAAA;cAMhB,wBAAwB,iBAC5B,6CAEP,YACA;EAEM,OAAO,OAAO,YAAY,MAAM,mBAAmB,QAAQ;EAG3D,OAAO,MAAM,YAAY,MAAM,mBAAmB,QAAQ;EAGhE,WAAW,OAAO,aAAa;EAG/B,WAAW,MAAM,YAAY;;cAclB,6BAA6B;YACrB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,0EAAgB,WAAA;cAMhB,4BAA4B,iBAChC,kEAGP;UAGQ;EAWF,OAAO,OAAO,MAAM,MAAM,mBAAmB;EAG7C,OAAO,cAAc,MAAM,mBAAmB,QAAQ;EAG5D,WAAW,OAAO,OAAO;EAGzB,WAAW,MAAM,YAAY;;cAYlB,iCAAiC;YACzB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,8EAAoB,WAAA;cAMpB,wBAAwB,iBAC5B,sDAEE,WACT;EAEM,OAAO,OAAO,WAAW,MAAM,mBAAmB;EAGlD,OAAO,eAAe,WAAW,MAAM,mBAAmB,QAAQ;EAGxE,WAAW,OAAO,YAAY;EAG9B,WAAW,MAAM,YAAY;;cAKlB,6BAA6B;YACrB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,0EAAgB,WAAA;cAMhB,0BAA0B,iBAC9B;EAKD,OAAO,eAAe,MAAM,mBAAmB;EAG/C,OAAO,uBAAuB,MAAM,mBAAmB;EAG7D,WAAW,gBAAgB;EAW3B,WAAW,MAAM;;cAmBN,+BAA+B;YACvB,eAAe,YAAY,iBAAiB;WAG7C;WACA;WACA;WACA,8CAAY;EACrB,YAAY,KAAK,yBAAyB;;cAOxC,4EAAkB,WAAA;;;;;;;;cC7XlB,qBAAqB;cAGrB,+BAAA"}

package/dist/codecs.d.mts

@@ -1,2 +1,2 @@
-import { a as SqliteIntegerDescriptor, c as SqliteTextDescriptor, d as sqliteDatetimeColumn, f as sqliteIntegerColumn, g as JsonValue, h as sqliteTextColumn, i as SqliteDatetimeDescriptor, l as sqliteBigintColumn, m as sqliteRealColumn, n as SqliteBigintDescriptor, o as SqliteJsonDescriptor, p as sqliteJsonColumn, r as SqliteBlobDescriptor, s as SqliteRealDescriptor, t as sqliteCodecRegistry, u as sqliteBlobColumn } from "./codecs-DGgo--O0.mjs";
-export { type JsonValue, type SqliteBigintDescriptor, type SqliteBlobDescriptor, type SqliteDatetimeDescriptor, type SqliteIntegerDescriptor, type SqliteJsonDescriptor, type SqliteRealDescriptor, type SqliteTextDescriptor, sqliteBigintColumn, sqliteBlobColumn, sqliteCodecRegistry, sqliteDatetimeColumn, sqliteIntegerColumn, sqliteJsonColumn, sqliteRealColumn, sqliteTextColumn };
+import { _ as JsonValue, a as SqliteDatetimeDescriptor, c as SqliteRealDescriptor, d as sqliteBlobColumn, f as sqliteDatetimeColumn, g as sqliteTextColumn, h as sqliteRealColumn, i as SqliteBlobDescriptor, l as SqliteTextDescriptor, m as sqliteJsonColumn, n as sqliteCodecRegistry, o as SqliteIntegerDescriptor, p as sqliteIntegerColumn, r as SqliteBigintDescriptor, s as SqliteJsonDescriptor, t as sqliteCodecDescriptorRegistry, u as sqliteBigintColumn } from "./codecs-D7gJOOpT.mjs";
+export { type JsonValue, type SqliteBigintDescriptor, type SqliteBlobDescriptor, type SqliteDatetimeDescriptor, type SqliteIntegerDescriptor, type SqliteJsonDescriptor, type SqliteRealDescriptor, type SqliteTextDescriptor, sqliteBigintColumn, sqliteBlobColumn, sqliteCodecDescriptorRegistry, sqliteCodecRegistry, sqliteDatetimeColumn, sqliteIntegerColumn, sqliteJsonColumn, sqliteRealColumn, sqliteTextColumn };

package/dist/codecs.mjs

@@ -1,9 +1,15 @@
 import { a as SQLITE_JSON_CODEC_ID, i as SQLITE_INTEGER_CODEC_ID, n as SQLITE_BLOB_CODEC_ID, o as SQLITE_REAL_CODEC_ID, r as SQLITE_DATETIME_CODEC_ID, s as SQLITE_TEXT_CODEC_ID, t as SQLITE_BIGINT_CODEC_ID } from "./codec-ids-DSU7S2Li.mjs";
-import { n as sqliteError } from "./errors-B1JPoWDh.mjs";
+import { a as sqliteCodec, n as buildSqliteCodecDescriptorRegistry, r as defineSqliteCodecs, t as SqliteCodecDescriptor } from "./codec-descriptor-DuYu6llI.mjs";
+import { n as sqliteError } from "./errors-By5PHAHj.mjs";
 import { sqlCharDescriptor, sqlFloatDescriptor, sqlIntDescriptor, sqlVarcharDescriptor } from "@prisma-next/sql-relational-core/ast";
-import { CodecDescriptorImpl, CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec";
+import { CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec";
 import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
 //#region src/core/codecs.ts
+const identityJsonProjection = (expression) => expression;
+const sqliteSqlCharDescriptor = sqliteCodec(sqlCharDescriptor, { jsonProjection: identityJsonProjection });
+const sqliteSqlVarcharDescriptor = sqliteCodec(sqlVarcharDescriptor, { jsonProjection: identityJsonProjection });
+const sqliteSqlIntDescriptor = sqliteCodec(sqlIntDescriptor, { jsonProjection: identityJsonProjection });
+const sqliteSqlFloatDescriptor = sqliteCodec(sqlFloatDescriptor, { jsonProjection: identityJsonProjection });
 var SqliteTextCodec = class extends CodecImpl {
 	async encode(value, _ctx) {
 		return value;
@@ -18,7 +24,10 @@ var SqliteTextCodec = class extends CodecImpl {
 		return json;
 	}
 };
-var SqliteTextDescriptor = class extends CodecDescriptorImpl {
+var SqliteTextDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_TEXT_CODEC_ID;
 	traits = [
 		"equality",
@@ -47,7 +56,10 @@ var SqliteIntegerCodec = class extends CodecImpl {
 		return json;
 	}
 };
-var SqliteIntegerDescriptor = class extends CodecDescriptorImpl {
+var SqliteIntegerDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_INTEGER_CODEC_ID;
 	traits = [
 		"equality",
@@ -76,7 +88,10 @@ var SqliteRealCodec = class extends CodecImpl {
 		return json;
 	}
 };
-var SqliteRealDescriptor = class extends CodecDescriptorImpl {
+var SqliteRealDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_REAL_CODEC_ID;
 	traits = [
 		"equality",
@@ -109,7 +124,10 @@ var SqliteBlobCodec = class extends CodecImpl {
 		return new Uint8Array(Buffer.from(json, "base64"));
 	}
 };
-var SqliteBlobDescriptor = class extends CodecDescriptorImpl {
+var SqliteBlobDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_BLOB_CODEC_ID;
 	traits = ["equality"];
 	targetTypes = ["blob"];
@@ -146,7 +164,10 @@ var SqliteDatetimeCodec = class extends CodecImpl {
 		return this.parseDate(json);
 	}
 };
-var SqliteDatetimeDescriptor = class extends CodecDescriptorImpl {
+var SqliteDatetimeDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_DATETIME_CODEC_ID;
 	traits = ["equality", "order"];
 	targetTypes = ["text"];
@@ -171,7 +192,10 @@ var SqliteJsonCodec = class extends CodecImpl {
 		return json;
 	}
 };
-var SqliteJsonDescriptor = class extends CodecDescriptorImpl {
+var SqliteJsonDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_JSON_CODEC_ID;
 	traits = ["equality"];
 	targetTypes = ["text"];
@@ -209,7 +233,10 @@ var SqliteBigintCodec = class extends CodecImpl {
 		return BigInt(json);
 	}
 };
-var SqliteBigintDescriptor = class extends CodecDescriptorImpl {
+var SqliteBigintDescriptor = class extends SqliteCodecDescriptor {
+	jsonProjection(expression) {
+		return expression;
+	}
 	codecId = SQLITE_BIGINT_CODEC_ID;
 	traits = [
 		"equality",
@@ -224,18 +251,11 @@ var SqliteBigintDescriptor = class extends CodecDescriptorImpl {
 };
 const sqliteBigintDescriptor = new SqliteBigintDescriptor();
 const sqliteBigintColumn = () => column(sqliteBigintDescriptor.factory(), sqliteBigintDescriptor.codecId, void 0, "integer");
-//#endregion
-//#region src/core/registry.ts
-/**
-* 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.
-*/
-const sqliteCodecRegistry = buildCodecDescriptorRegistry([
-	sqlCharDescriptor,
-	sqlVarcharDescriptor,
-	sqlIntDescriptor,
-	sqlFloatDescriptor,
+const codecDescriptors = defineSqliteCodecs([
+	sqliteSqlCharDescriptor,
+	sqliteSqlVarcharDescriptor,
+	sqliteSqlIntDescriptor,
+	sqliteSqlFloatDescriptor,
 	sqliteTextDescriptor,
 	sqliteIntegerDescriptor,
 	sqliteRealDescriptor,
@@ -245,6 +265,15 @@ const sqliteCodecRegistry = buildCodecDescriptorRegistry([
 	sqliteBigintDescriptor
 ]);
 //#endregion
-export { sqliteBigintColumn, sqliteBlobColumn, sqliteCodecRegistry, sqliteDatetimeColumn, sqliteIntegerColumn, sqliteJsonColumn, sqliteRealColumn, sqliteTextColumn };
+//#region src/core/registry.ts
+/**
+* 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.
+*/
+const sqliteCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
+const sqliteCodecDescriptorRegistry = buildSqliteCodecDescriptorRegistry(codecDescriptors);
+//#endregion
+export { sqliteBigintColumn, sqliteBlobColumn, sqliteCodecDescriptorRegistry, sqliteCodecRegistry, sqliteDatetimeColumn, sqliteIntegerColumn, sqliteJsonColumn, sqliteRealColumn, sqliteTextColumn };
 
 //# sourceMappingURL=codecs.mjs.map

package/dist/codecs.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"codecs.mjs","names":[],"sources":["../src/core/codecs.ts","../src/core/registry.ts"],"sourcesContent":["/**\n * Native SQLite target codecs (TML-2357). Mirrors the Postgres codec class form in `packages/3-targets/3-targets/postgres/src/core/codecs.ts`.\n *\n * Each codec ships as three artifacts:\n *\n * 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\n * `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).\n *\n * 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.\n *\n * 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`.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n  type AnyCodecDescriptor,\n  type CodecCallContext,\n  CodecDescriptorImpl,\n  CodecImpl,\n  type CodecInstanceContext,\n  type ColumnHelperFor,\n  type ColumnHelperForStrict,\n  column,\n  voidParamsSchema,\n} from '@prisma-next/framework-components/codec';\nimport {\n  sqlCharDescriptor,\n  sqlFloatDescriptor,\n  sqlIntDescriptor,\n  sqlVarcharDescriptor,\n} from '@prisma-next/sql-relational-core/ast';\nimport {\n  SQLITE_BIGINT_CODEC_ID,\n  SQLITE_BLOB_CODEC_ID,\n  SQLITE_DATETIME_CODEC_ID,\n  SQLITE_INTEGER_CODEC_ID,\n  SQLITE_JSON_CODEC_ID,\n  SQLITE_REAL_CODEC_ID,\n  SQLITE_TEXT_CODEC_ID,\n} from './codec-ids';\nimport { sqliteError } from './errors';\n\nexport class SqliteTextCodec extends CodecImpl<\n  typeof SQLITE_TEXT_CODEC_ID,\n  readonly ['equality', 'order', 'textual'],\n  string,\n  string\n> {\n  async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n    return value;\n  }\n  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n    return wire;\n  }\n  encodeJson(value: string): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): string {\n    return json as string;\n  }\n}\n\nexport class SqliteTextDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_TEXT_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'textual'] as const;\n  override readonly targetTypes = ['text'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteTextCodec {\n    return () => new SqliteTextCodec(this);\n  }\n}\n\nexport const sqliteTextDescriptor = new SqliteTextDescriptor();\n\nexport const sqliteTextColumn = () =>\n  column(sqliteTextDescriptor.factory(), sqliteTextDescriptor.codecId, undefined, 'text');\n\nsqliteTextColumn satisfies ColumnHelperFor<SqliteTextDescriptor>;\nsqliteTextColumn satisfies ColumnHelperForStrict<SqliteTextDescriptor>;\n\nexport class SqliteIntegerCodec extends CodecImpl<\n  typeof SQLITE_INTEGER_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  number,\n  number\n> {\n  async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n    return value;\n  }\n  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n    return wire;\n  }\n  encodeJson(value: number): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): number {\n    return json as number;\n  }\n}\n\nexport class SqliteIntegerDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_INTEGER_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'numeric'] as const;\n  override readonly targetTypes = ['integer'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteIntegerCodec {\n    return () => new SqliteIntegerCodec(this);\n  }\n}\n\nexport const sqliteIntegerDescriptor = new SqliteIntegerDescriptor();\n\nexport const sqliteIntegerColumn = () =>\n  column(sqliteIntegerDescriptor.factory(), sqliteIntegerDescriptor.codecId, undefined, 'integer');\n\nsqliteIntegerColumn satisfies ColumnHelperFor<SqliteIntegerDescriptor>;\nsqliteIntegerColumn satisfies ColumnHelperForStrict<SqliteIntegerDescriptor>;\n\nexport class SqliteRealCodec extends CodecImpl<\n  typeof SQLITE_REAL_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  number,\n  number\n> {\n  async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n    return value;\n  }\n  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n    return wire;\n  }\n  encodeJson(value: number): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): number {\n    return json as number;\n  }\n}\n\nexport class SqliteRealDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_REAL_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'numeric'] as const;\n  override readonly targetTypes = ['real'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteRealCodec {\n    return () => new SqliteRealCodec(this);\n  }\n}\n\nexport const sqliteRealDescriptor = new SqliteRealDescriptor();\n\nexport const sqliteRealColumn = () =>\n  column(sqliteRealDescriptor.factory(), sqliteRealDescriptor.codecId, undefined, 'real');\n\nsqliteRealColumn satisfies ColumnHelperFor<SqliteRealDescriptor>;\nsqliteRealColumn satisfies ColumnHelperForStrict<SqliteRealDescriptor>;\n\nexport class SqliteBlobCodec extends CodecImpl<\n  typeof SQLITE_BLOB_CODEC_ID,\n  readonly ['equality'],\n  Uint8Array,\n  Uint8Array\n> {\n  async encode(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {\n    return value;\n  }\n  async decode(wire: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {\n    return wire;\n  }\n  encodeJson(value: Uint8Array): JsonValue {\n    return Buffer.from(value).toString('base64');\n  }\n  decodeJson(json: JsonValue): Uint8Array {\n    if (typeof json !== 'string') {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/blob@1 contract value must be a base64 string',\n        {\n          meta: { codecId: SQLITE_BLOB_CODEC_ID, received: typeof json },\n        },\n      );\n    }\n    return new Uint8Array(Buffer.from(json, 'base64'));\n  }\n}\n\nexport class SqliteBlobDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_BLOB_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = ['blob'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteBlobCodec {\n    return () => new SqliteBlobCodec(this);\n  }\n}\n\nexport const sqliteBlobDescriptor = new SqliteBlobDescriptor();\n\nexport const sqliteBlobColumn = () =>\n  column(sqliteBlobDescriptor.factory(), sqliteBlobDescriptor.codecId, undefined, 'blob');\n\nsqliteBlobColumn satisfies ColumnHelperFor<SqliteBlobDescriptor>;\nsqliteBlobColumn satisfies ColumnHelperForStrict<SqliteBlobDescriptor>;\n\nexport class SqliteDatetimeCodec extends CodecImpl<\n  typeof SQLITE_DATETIME_CODEC_ID,\n  readonly ['equality', 'order'],\n  string,\n  Date\n> {\n  // 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.\n  private parseDate(value: string): Date {\n    const date = new Date(value);\n    if (Number.isNaN(date.getTime())) {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        `sqlite/datetime@1 value must be a valid ISO-8601 string: ${value}`,\n        { meta: { codecId: SQLITE_DATETIME_CODEC_ID, received: value } },\n      );\n    }\n    return date;\n  }\n  async encode(value: Date, _ctx: CodecCallContext): Promise<string> {\n    return value.toISOString();\n  }\n  async decode(wire: string, _ctx: CodecCallContext): Promise<Date> {\n    return this.parseDate(wire);\n  }\n  encodeJson(value: Date): JsonValue {\n    return value.toISOString();\n  }\n  decodeJson(json: JsonValue): Date {\n    if (typeof json !== 'string') {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/datetime@1 contract value must be an ISO-8601 string',\n        { meta: { codecId: SQLITE_DATETIME_CODEC_ID, received: typeof json } },\n      );\n    }\n    return this.parseDate(json);\n  }\n}\n\nexport class SqliteDatetimeDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_DATETIME_CODEC_ID;\n  override readonly traits = ['equality', 'order'] as const;\n  override readonly targetTypes = ['text'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteDatetimeCodec {\n    return () => new SqliteDatetimeCodec(this);\n  }\n}\n\nexport const sqliteDatetimeDescriptor = new SqliteDatetimeDescriptor();\n\nexport const sqliteDatetimeColumn = () =>\n  column(sqliteDatetimeDescriptor.factory(), sqliteDatetimeDescriptor.codecId, undefined, 'text');\n\nsqliteDatetimeColumn satisfies ColumnHelperFor<SqliteDatetimeDescriptor>;\nsqliteDatetimeColumn satisfies ColumnHelperForStrict<SqliteDatetimeDescriptor>;\n\nexport class SqliteJsonCodec extends CodecImpl<\n  typeof SQLITE_JSON_CODEC_ID,\n  readonly ['equality'],\n  string | JsonValue,\n  JsonValue\n> {\n  async encode(value: JsonValue, _ctx: CodecCallContext): Promise<string> {\n    return JSON.stringify(value);\n  }\n  async decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue> {\n    return typeof wire === 'string' ? (JSON.parse(wire) as JsonValue) : wire;\n  }\n  encodeJson(value: JsonValue): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): JsonValue {\n    return json;\n  }\n}\n\nexport class SqliteJsonDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_JSON_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = ['text'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteJsonCodec {\n    return () => new SqliteJsonCodec(this);\n  }\n}\n\nexport const sqliteJsonDescriptor = new SqliteJsonDescriptor();\n\nexport const sqliteJsonColumn = () =>\n  column(sqliteJsonDescriptor.factory(), sqliteJsonDescriptor.codecId, undefined, 'text');\n\nsqliteJsonColumn satisfies ColumnHelperFor<SqliteJsonDescriptor>;\nsqliteJsonColumn satisfies ColumnHelperForStrict<SqliteJsonDescriptor>;\n\nexport class SqliteBigintCodec extends CodecImpl<\n  typeof SQLITE_BIGINT_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  number | bigint,\n  bigint\n> {\n  async encode(value: bigint, _ctx: CodecCallContext): Promise<number | bigint> {\n    return value;\n  }\n  async decode(wire: number | bigint, _ctx: CodecCallContext): Promise<bigint> {\n    return BigInt(wire);\n  }\n  encodeJson(value: bigint): JsonValue {\n    const number = Number(value);\n    if (!Number.isSafeInteger(number)) {\n      throw sqliteError(\n        'RUNTIME.ENCODE_FAILED',\n        'sqlite/bigint@1 database JSON value must be a safe integer',\n        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: String(value) } },\n      );\n    }\n    return number;\n  }\n  decodeJson(json: JsonValue): bigint {\n    if (typeof json !== 'number') {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/bigint@1 database JSON value must be a number',\n        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: typeof json } },\n      );\n    }\n    if (!Number.isSafeInteger(json)) {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/bigint@1 database JSON value must be a safe integer',\n        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: json } },\n      );\n    }\n    return BigInt(json);\n  }\n}\n\nexport class SqliteBigintDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = SQLITE_BIGINT_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'numeric'] as const;\n  override readonly targetTypes = ['integer'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteBigintCodec {\n    return () => new SqliteBigintCodec(this);\n  }\n}\n\nexport const sqliteBigintDescriptor = new SqliteBigintDescriptor();\n\nexport const sqliteBigintColumn = () =>\n  column(sqliteBigintDescriptor.factory(), sqliteBigintDescriptor.codecId, undefined, 'integer');\n\nsqliteBigintColumn satisfies ColumnHelperFor<SqliteBigintDescriptor>;\nsqliteBigintColumn satisfies ColumnHelperForStrict<SqliteBigintDescriptor>;\n\nexport const codecDescriptors: readonly AnyCodecDescriptor[] = [\n  sqlCharDescriptor,\n  sqlVarcharDescriptor,\n  sqlIntDescriptor,\n  sqlFloatDescriptor,\n  sqliteTextDescriptor,\n  sqliteIntegerDescriptor,\n  sqliteRealDescriptor,\n  sqliteBlobDescriptor,\n  sqliteDatetimeDescriptor,\n  sqliteJsonDescriptor,\n  sqliteBigintDescriptor,\n];\n","import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';\nimport type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';\nimport { codecDescriptors } from './codecs';\n\n/**\n * Registry of every codec descriptor shipped by `@prisma-next/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 */\nexport const sqliteCodecRegistry: CodecDescriptorRegistry =\n  buildCodecDescriptorRegistry(codecDescriptors);\n"],"mappings":"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"}
+{"version":3,"file":"codecs.mjs","names":[],"sources":["../src/core/codecs.ts","../src/core/registry.ts"],"sourcesContent":["/**\n * Native SQLite target codecs (TML-2357). Mirrors the Postgres codec class form in `packages/3-targets/3-targets/postgres/src/core/codecs.ts`.\n *\n * Each codec ships as three artifacts:\n *\n * 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\n * `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).\n *\n * 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.\n *\n * 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`.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n  type CodecCallContext,\n  CodecImpl,\n  type CodecInstanceContext,\n  type ColumnHelperFor,\n  type ColumnHelperForStrict,\n  column,\n  voidParamsSchema,\n} from '@prisma-next/framework-components/codec';\nimport {\n  type ProjectionExpr,\n  sqlCharDescriptor,\n  sqlFloatDescriptor,\n  sqlIntDescriptor,\n  sqlVarcharDescriptor,\n} from '@prisma-next/sql-relational-core/ast';\nimport { defineSqliteCodecs, SqliteCodecDescriptor, sqliteCodec } from './codec-descriptor';\nimport {\n  SQLITE_BIGINT_CODEC_ID,\n  SQLITE_BLOB_CODEC_ID,\n  SQLITE_DATETIME_CODEC_ID,\n  SQLITE_INTEGER_CODEC_ID,\n  SQLITE_JSON_CODEC_ID,\n  SQLITE_REAL_CODEC_ID,\n  SQLITE_TEXT_CODEC_ID,\n} from './codec-ids';\nimport { sqliteError } from './errors';\n\nconst identityJsonProjection = (expression: ProjectionExpr): ProjectionExpr => expression;\n\nexport const sqliteSqlCharDescriptor = sqliteCodec(sqlCharDescriptor, {\n  jsonProjection: identityJsonProjection,\n});\n\nexport const sqliteSqlVarcharDescriptor = sqliteCodec(sqlVarcharDescriptor, {\n  jsonProjection: identityJsonProjection,\n});\n\nexport const sqliteSqlIntDescriptor = sqliteCodec(sqlIntDescriptor, {\n  jsonProjection: identityJsonProjection,\n});\n\nexport const sqliteSqlFloatDescriptor = sqliteCodec(sqlFloatDescriptor, {\n  jsonProjection: identityJsonProjection,\n});\n\nexport class SqliteTextCodec extends CodecImpl<\n  typeof SQLITE_TEXT_CODEC_ID,\n  readonly ['equality', 'order', 'textual'],\n  string,\n  string\n> {\n  async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n    return value;\n  }\n  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n    return wire;\n  }\n  encodeJson(value: string): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): string {\n    return json as string;\n  }\n}\n\nexport class SqliteTextDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_TEXT_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'textual'] as const;\n  override readonly targetTypes = ['text'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteTextCodec {\n    return () => new SqliteTextCodec(this);\n  }\n}\n\nexport const sqliteTextDescriptor = new SqliteTextDescriptor();\n\nexport const sqliteTextColumn = () =>\n  column(sqliteTextDescriptor.factory(), sqliteTextDescriptor.codecId, undefined, 'text');\n\nsqliteTextColumn satisfies ColumnHelperFor<SqliteTextDescriptor>;\nsqliteTextColumn satisfies ColumnHelperForStrict<SqliteTextDescriptor>;\n\nexport class SqliteIntegerCodec extends CodecImpl<\n  typeof SQLITE_INTEGER_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  number,\n  number\n> {\n  async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n    return value;\n  }\n  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n    return wire;\n  }\n  encodeJson(value: number): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): number {\n    return json as number;\n  }\n}\n\nexport class SqliteIntegerDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_INTEGER_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'numeric'] as const;\n  override readonly targetTypes = ['integer'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteIntegerCodec {\n    return () => new SqliteIntegerCodec(this);\n  }\n}\n\nexport const sqliteIntegerDescriptor = new SqliteIntegerDescriptor();\n\nexport const sqliteIntegerColumn = () =>\n  column(sqliteIntegerDescriptor.factory(), sqliteIntegerDescriptor.codecId, undefined, 'integer');\n\nsqliteIntegerColumn satisfies ColumnHelperFor<SqliteIntegerDescriptor>;\nsqliteIntegerColumn satisfies ColumnHelperForStrict<SqliteIntegerDescriptor>;\n\nexport class SqliteRealCodec extends CodecImpl<\n  typeof SQLITE_REAL_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  number,\n  number\n> {\n  async encode(value: number, _ctx: CodecCallContext): Promise<number> {\n    return value;\n  }\n  async decode(wire: number, _ctx: CodecCallContext): Promise<number> {\n    return wire;\n  }\n  encodeJson(value: number): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): number {\n    return json as number;\n  }\n}\n\nexport class SqliteRealDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_REAL_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'numeric'] as const;\n  override readonly targetTypes = ['real'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteRealCodec {\n    return () => new SqliteRealCodec(this);\n  }\n}\n\nexport const sqliteRealDescriptor = new SqliteRealDescriptor();\n\nexport const sqliteRealColumn = () =>\n  column(sqliteRealDescriptor.factory(), sqliteRealDescriptor.codecId, undefined, 'real');\n\nsqliteRealColumn satisfies ColumnHelperFor<SqliteRealDescriptor>;\nsqliteRealColumn satisfies ColumnHelperForStrict<SqliteRealDescriptor>;\n\nexport class SqliteBlobCodec extends CodecImpl<\n  typeof SQLITE_BLOB_CODEC_ID,\n  readonly ['equality'],\n  Uint8Array,\n  Uint8Array\n> {\n  async encode(value: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {\n    return value;\n  }\n  async decode(wire: Uint8Array, _ctx: CodecCallContext): Promise<Uint8Array> {\n    return wire;\n  }\n  encodeJson(value: Uint8Array): JsonValue {\n    return Buffer.from(value).toString('base64');\n  }\n  decodeJson(json: JsonValue): Uint8Array {\n    if (typeof json !== 'string') {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/blob@1 contract value must be a base64 string',\n        {\n          meta: { codecId: SQLITE_BLOB_CODEC_ID, received: typeof json },\n        },\n      );\n    }\n    return new Uint8Array(Buffer.from(json, 'base64'));\n  }\n}\n\nexport class SqliteBlobDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_BLOB_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = ['blob'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteBlobCodec {\n    return () => new SqliteBlobCodec(this);\n  }\n}\n\nexport const sqliteBlobDescriptor = new SqliteBlobDescriptor();\n\nexport const sqliteBlobColumn = () =>\n  column(sqliteBlobDescriptor.factory(), sqliteBlobDescriptor.codecId, undefined, 'blob');\n\nsqliteBlobColumn satisfies ColumnHelperFor<SqliteBlobDescriptor>;\nsqliteBlobColumn satisfies ColumnHelperForStrict<SqliteBlobDescriptor>;\n\nexport class SqliteDatetimeCodec extends CodecImpl<\n  typeof SQLITE_DATETIME_CODEC_ID,\n  readonly ['equality', 'order'],\n  string,\n  Date\n> {\n  // 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.\n  private parseDate(value: string): Date {\n    const date = new Date(value);\n    if (Number.isNaN(date.getTime())) {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        `sqlite/datetime@1 value must be a valid ISO-8601 string: ${value}`,\n        { meta: { codecId: SQLITE_DATETIME_CODEC_ID, received: value } },\n      );\n    }\n    return date;\n  }\n  async encode(value: Date, _ctx: CodecCallContext): Promise<string> {\n    return value.toISOString();\n  }\n  async decode(wire: string, _ctx: CodecCallContext): Promise<Date> {\n    return this.parseDate(wire);\n  }\n  encodeJson(value: Date): JsonValue {\n    return value.toISOString();\n  }\n  decodeJson(json: JsonValue): Date {\n    if (typeof json !== 'string') {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/datetime@1 contract value must be an ISO-8601 string',\n        { meta: { codecId: SQLITE_DATETIME_CODEC_ID, received: typeof json } },\n      );\n    }\n    return this.parseDate(json);\n  }\n}\n\nexport class SqliteDatetimeDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_DATETIME_CODEC_ID;\n  override readonly traits = ['equality', 'order'] as const;\n  override readonly targetTypes = ['text'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteDatetimeCodec {\n    return () => new SqliteDatetimeCodec(this);\n  }\n}\n\nexport const sqliteDatetimeDescriptor = new SqliteDatetimeDescriptor();\n\nexport const sqliteDatetimeColumn = () =>\n  column(sqliteDatetimeDescriptor.factory(), sqliteDatetimeDescriptor.codecId, undefined, 'text');\n\nsqliteDatetimeColumn satisfies ColumnHelperFor<SqliteDatetimeDescriptor>;\nsqliteDatetimeColumn satisfies ColumnHelperForStrict<SqliteDatetimeDescriptor>;\n\nexport class SqliteJsonCodec extends CodecImpl<\n  typeof SQLITE_JSON_CODEC_ID,\n  readonly ['equality'],\n  string | JsonValue,\n  JsonValue\n> {\n  async encode(value: JsonValue, _ctx: CodecCallContext): Promise<string> {\n    return JSON.stringify(value);\n  }\n  async decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<JsonValue> {\n    return typeof wire === 'string' ? (JSON.parse(wire) as JsonValue) : wire;\n  }\n  encodeJson(value: JsonValue): JsonValue {\n    return value;\n  }\n  decodeJson(json: JsonValue): JsonValue {\n    return json;\n  }\n}\n\nexport class SqliteJsonDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_JSON_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = ['text'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteJsonCodec {\n    return () => new SqliteJsonCodec(this);\n  }\n}\n\nexport const sqliteJsonDescriptor = new SqliteJsonDescriptor();\n\nexport const sqliteJsonColumn = () =>\n  column(sqliteJsonDescriptor.factory(), sqliteJsonDescriptor.codecId, undefined, 'text');\n\nsqliteJsonColumn satisfies ColumnHelperFor<SqliteJsonDescriptor>;\nsqliteJsonColumn satisfies ColumnHelperForStrict<SqliteJsonDescriptor>;\n\nexport class SqliteBigintCodec extends CodecImpl<\n  typeof SQLITE_BIGINT_CODEC_ID,\n  readonly ['equality', 'order', 'numeric'],\n  number | bigint,\n  bigint\n> {\n  async encode(value: bigint, _ctx: CodecCallContext): Promise<number | bigint> {\n    return value;\n  }\n  async decode(wire: number | bigint, _ctx: CodecCallContext): Promise<bigint> {\n    return BigInt(wire);\n  }\n  encodeJson(value: bigint): JsonValue {\n    const number = Number(value);\n    if (!Number.isSafeInteger(number)) {\n      throw sqliteError(\n        'RUNTIME.ENCODE_FAILED',\n        'sqlite/bigint@1 database JSON value must be a safe integer',\n        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: String(value) } },\n      );\n    }\n    return number;\n  }\n  decodeJson(json: JsonValue): bigint {\n    if (typeof json !== 'number') {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/bigint@1 database JSON value must be a number',\n        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: typeof json } },\n      );\n    }\n    if (!Number.isSafeInteger(json)) {\n      throw sqliteError(\n        'RUNTIME.DECODE_FAILED',\n        'sqlite/bigint@1 database JSON value must be a safe integer',\n        { meta: { codecId: SQLITE_BIGINT_CODEC_ID, received: json } },\n      );\n    }\n    return BigInt(json);\n  }\n}\n\nexport class SqliteBigintDescriptor extends SqliteCodecDescriptor<void> {\n  protected override jsonProjection(expression: ProjectionExpr): ProjectionExpr {\n    return expression;\n  }\n  override readonly codecId = SQLITE_BIGINT_CODEC_ID;\n  override readonly traits = ['equality', 'order', 'numeric'] as const;\n  override readonly targetTypes = ['integer'] as const;\n  override readonly paramsSchema = voidParamsSchema;\n  override factory(): (ctx: CodecInstanceContext) => SqliteBigintCodec {\n    return () => new SqliteBigintCodec(this);\n  }\n}\n\nexport const sqliteBigintDescriptor = new SqliteBigintDescriptor();\n\nexport const sqliteBigintColumn = () =>\n  column(sqliteBigintDescriptor.factory(), sqliteBigintDescriptor.codecId, undefined, 'integer');\n\nsqliteBigintColumn satisfies ColumnHelperFor<SqliteBigintDescriptor>;\nsqliteBigintColumn satisfies ColumnHelperForStrict<SqliteBigintDescriptor>;\n\nexport const codecDescriptors = defineSqliteCodecs([\n  sqliteSqlCharDescriptor,\n  sqliteSqlVarcharDescriptor,\n  sqliteSqlIntDescriptor,\n  sqliteSqlFloatDescriptor,\n  sqliteTextDescriptor,\n  sqliteIntegerDescriptor,\n  sqliteRealDescriptor,\n  sqliteBlobDescriptor,\n  sqliteDatetimeDescriptor,\n  sqliteJsonDescriptor,\n  sqliteBigintDescriptor,\n]);\n","import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';\nimport type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';\nimport { buildSqliteCodecDescriptorRegistry } from './codec-descriptor';\nimport { codecDescriptors } from './codecs';\n\n/**\n * Registry of every codec descriptor shipped by `@prisma-next/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 */\nexport const sqliteCodecRegistry: CodecDescriptorRegistry =\n  buildCodecDescriptorRegistry(codecDescriptors);\n\nexport const sqliteCodecDescriptorRegistry = buildSqliteCodecDescriptorRegistry(codecDescriptors);\n"],"mappings":"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"}

package/dist/control.mjs

@@ -1,13 +1,13 @@
-import { n as sqliteError } from "./errors-B1JPoWDh.mjs";
+import { n as sqliteError } from "./errors-By5PHAHj.mjs";
 import { t as sqliteTargetDescriptorMeta } from "./descriptor-meta-BPrgV878.mjs";
-import { a as verifySqliteDatabaseSchema, i as sqliteContractToSchema, n as createSqliteMigrationPlanner, r as diffSqliteSchema } from "./planner-ByBNEpyf.mjs";
+import { a as verifySqliteDatabaseSchema, i as sqliteContractToSchema, n as createSqliteMigrationPlanner, r as diffSqliteSchema } from "./planner-CuM2U40p.mjs";
 import { r as MARKER_TABLE_NAME } from "./control-tables-D_o8dKRB.mjs";
-import { i as sqliteCreateNamespace, n as SqliteContractSerializer, r as SqliteUnboundDatabase } from "./sqlite-contract-view-BKHdFV5Y.mjs";
+import { i as sqliteCreateNamespace, n as SqliteContractSerializer, r as SqliteUnboundDatabase } from "./sqlite-contract-view-C9DFAHHV.mjs";
+import { blindCast } from "@prisma-next/utils/casts";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { relationalNodeEntityKind, relationalNodeGranularity } from "@prisma-next/sql-schema-ir/types";
 import { runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
-import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 import { InternalError } from "@prisma-next/utils/internal-error";

package/dist/{errors-B1JPoWDh.mjs → errors-By5PHAHj.mjs}

@@ -1,5 +1,5 @@
-import { CliStructuredError } from "@prisma-next/errors/control";
 import { structuredError } from "@prisma-next/utils/structured-error";
+import { CliStructuredError } from "@prisma-next/errors/control";
 //#region src/core/errors.ts
 function sqliteError(code, message, options) {
 	return structuredError(code, message, options);
@@ -35,4 +35,4 @@ function errorSqliteMigrationStackMissing(operation) {
 //#endregion
 export { sqliteError as n, errorSqliteMigrationStackMissing as t };
 
-//# sourceMappingURL=errors-B1JPoWDh.mjs.map
+//# sourceMappingURL=errors-By5PHAHj.mjs.map