feat(codec-registration-completion): unify codec registration (TML-2357)

[wmadden]

Status: ready for review. All milestones complete; all 14 acceptance criteria PASS or LANDED at HEAD; validation gates green workspace-wide.

Completes the registration-side migration that the parent codec-registry-unification project (merged via ADR 208) deliberately deferred. (TML-2357)

Spec & plan

• projects/codec-registration-completion/spec.md — eight ACs (AC-0..AC-7), three pinning cases.
• projects/codec-registration-completion/plan.md — five milestones with validation gates and risks.
• projects/codec-registration-completion/specs/class-based-codec-design.spec.md — six implementation-level ACs (AC-CB-1..6) covering the Pattern E class hierarchy.

Milestones

#	Goal	Spec ACs	Status
M0	Class-based codec migration (Pattern E) + per-codec helpers + Strength 3 deletion sweep	AC-0, AC-1, AC-CB-1..6	SATISFIED at a210fa1c5
M1	Narrow runtime Codec instance + descriptor-keyed metadata reads	AC-3	LANDED at 1be7564c4; reverified through M4
M2	Native descriptor migration + bridge / aliasCodec / arktypeJsonEmitCodec deletion	AC-2, AC-4	ABSORBED into M0 (Phase B + Phase C)
M3	ParamRef.refs plumbing + encode-side forColumn + forCodecId retirement	AC-5	SATISFIED at 3f0ec224a
M4	Delete JsonSchemaValidatorRegistry; retire 'json-validator' trait	AC-6	SATISFIED at e055c9455
AC-7	Validation gates green	AC-7	PASS at every milestone close

What landed

• Class-based codec hierarchy. interface CodecDescriptor<P> + abstract class CodecDescriptorImpl<P>, paired with interface Codec<Id, Traits, Wire, Input> + abstract class CodecImpl<...>. Per-codec column helpers (e.g. vectorColumn(N)) directly invoke descriptor.factory(params) to preserve method-level generics; satisfies ColumnHelperFor<D> ties helpers to their descriptor without polymorphism. AnyCodecDescriptor (alias for CodecDescriptor<any>) is the canonical heterogeneous-storage type.
• Strength 3 forcing-function deletion. Every legacy carrier deleted: mkCodec, defineCodec, defineCodecGroup, defineCodecBundle, CodecDefBuilder*, synthesizeNonParameterizedDescriptor, instance-keyed ExtractCodecTypes, byScalar maps, dataTypes exports, sqlCodecDefinitions, codecDescriptorDefinitions, pgVectorRepresentativeCodec placeholder, parameterizedCodecs: slot, CodecParamsDescriptor, arktypeJsonEmitCodec, aliasCodec, aliasDescriptor function form, the 'json-validator' trait, JsonSchemaValidatorRegistry infrastructure. Closing-grep zero call-sites across all 19 retired symbols.
• ParamRef + ProjectionItem carry refs?: { table; column }; validateParamRefRefs builder-pipeline pass enforces refs for parameterized codec ids; encode/decode dispatch consults metadata.refs first via contractCodecs.forColumn(table, column).
• JSON validation lives in the resolved codec's decode body (arktype-json's inline pattern from TML-2229). Decode-error envelope equivalence verified via codec-async.test.ts:408-456.
• ColumnTypeDescriptor relocated from @prisma-next/contract-authoring (layer 2) to @prisma-next/framework-components (layer 1) so codec base types live with the framework primitives.
• F8 portability fix (fae3bd688): CodecTypes exposed at the public exports/codec-types.ts entry point with a Resolve<T> materializer to break tsdown's chunk-private path reference and restore consumer-side typecheck.

Notable side effect: 16 pre-existing e2e failures resolved by M3

Before M3, the e2e suite ran 75/91 with 16 failures of the form Codec '...' resolves to multiple parameterized instances; column-aware dispatch is required. — top-level field shortcuts (select('vectorCol')) emitted IdentifierRef AST that didn't carry (table, column) context, so decode-side resolveProjectionCodec fell back to forCodecId and threw. M3's ProjectionItem.refs extension + decode-side parity in decoding.ts closed the path. e2e is now 91/91.

Validation gates at HEAD 2d4eb3ba3

Gate	Result
pnpm typecheck --force	PASS — 123/123, 0 cached, 0 errors
pnpm lint:deps	PASS — 721 modules / 1429 deps / 0 violations
pnpm fixtures:check	PASS — zero drift (demo emit byte-identical against origin/main)
pnpm build	PASS — 62/62
pnpm test:e2e	PASS — 91/91 (16 pre-existing failures resolved by M3)
pnpm test:packages	PASS in scope (residual: pre-existing 7 sql-orm-client pgvector wire-format + TML-2402 parallel-flake)

Linear follow-ups filed during close-out

• TML-2402 — pnpm test:packages parallel-execution flake (adapter-postgres / cli / sql-orm-client; passes cleanly in isolation). P3.
• TML-2403 — Turbo cache-keying gap on transitive AST/type-system changes (worked around with pnpm build --force). P4.
• TML-2405 — Codec dispatch follow-up: reference codec instances on the lowered Plan instead of carrying (table, column) lookup keys on the AST. The current shape's validator pass is a smell; instance-on-Plan would retire forColumn/forCodecId from the runtime dispatch surface entirely. Architectural successor to this work. P3.

Out of scope

• Mongo codec registration migration — folded into TML-2324 (Mongo runtime forColumn plumbing).
• Renaming Codec — type name stays; only the field set narrows.
• Reshaping the async codec runtime (ADR 204) or CodecCallContext (ADR 207).
• pgEnumCodec placeholder factory audit (already clean at HEAD; documented in ADR 208 § Future work).

Note on project artifacts

Per the user's mid-flight directive at close-out, projects/codec-registration-completion/ is preserved in-tree (the standard transient-directory deletion was reverted at 5b0113a5a). The directory's review artifacts under reviews/ are gitignored and don't appear in the diff; they live in the working tree only as historical context.

  

Summary by CodeRabbit

• Documentation

  • Added comprehensive codec authoring guide with worked examples and best practices
  • Updated architecture decision records (ADRs) to reflect unified descriptor + instance codec model
  • Enhanced testing guidance with testing pyramid patterns and common anti-patterns

• New Features

  • Introduced unified codec descriptor system for consistent metadata and instance materialization

• Refactor

  • Migrated codec authoring from factory-based to class-based patterns for improved type safety
  • Reorganized codec registration and lookup infrastructure for streamlined dispatch

[coderabbitai]

📝 Walkthrough

Walkthrough

A systemic migration is made to a class-based codec and descriptor architecture, consolidating all registry, parameterization, trait, target type, meta, and type rendering onto descriptor classes and helpers. SQL, Postgres, SQLite, Mongo, and all extension and registry paths are rewritten for descriptor-based registration and lookup; all encode/decode operations are guaranteed Promise-based and column/context-rich. The change covers core frameworks, adapters, contract emission, storage and query plans, extension packs, ORM, and is fully mirrored in the docs, guides, and a comprehensive suite of upgraded tests and type-level assertions.

Changes

Codec Class, Descriptor, Registry, and End-to-End Unification Across Framework, Families, and Docs

Layer / File(s)	Summary
Framework: Class-based Codec, Descriptor, Type Helpers, and Registry Contracts framework-components/*, README, all trait/lookup/types/column helpers, base test/type assertion, core contract/doc patterns, and authoring test code	Introduces canonical CodecImpl/CodecDescriptorImpl and column helper APIs. All lookup/registration/traits/output/meta handling unified at the descriptor layer. Interface, type utility, and registry exports refactored; type assertion/testing and documentation/guides aligned.
SQL, Postgres, SQLite, Mongo, and Extension Registry/Adapter/Contribution Rewrites All storage family/adapter/extension registry/factory/lookup, metadata, and wiring code	All registry and adapter points rewritten for descriptor-driven/array contributions. Parameterization and trait/output/meta structured only on descriptor; all instance or split-parameterization logic is removed. Extension packs and adapter descriptors now contribute descriptors and materialize codecs only via descriptor factories.
Contract, Runtime, Query Orchestration, Dispatch, and Registry Pathways Contract generation, ORM, query planning, parameter registry/dispatch, registry/codec lookups	Contract, row decoding, param encoding, planner, and runtime logic is refactored for descriptor-aware pipelines: column helpers materialize, registry lookups become unified, parameterization is validated via descriptors, all runtime encode/decode are Promise-based, and output types are dispatched via descriptor.
SQL Builder, Storage, ORM, Column Ref/Param Finalization, and Extension Plumbing All query planner, field proxy, SQL mutation, builder, and ORM code tracking column (table, column) context/ref propagation	SQLBuilder, ORM, and mutation/assignment systems now propagate column provenance (refs) throughout plans, parameters, and expressions. All field proxies and resolved plan structures embed accurate table/column context, ensuring accurate downstream parameterization and typegen.
Systematic Test Migration: E2E, Model, Type-level, Registry/Param, Fixture/Coverage End-to-end runtime, registry, fixture, and authoring/type assertion test migration	All downstream integration, authoring, ORM, registry, type-level, and extension tests are migrated to the class-form/descriptor structure. All test helpers adopt new column helpers, parameterization, and registry patterns; all coverage reflects the new discipline, with comprehensive verification across runtime, registry, typegen, and extensions.

Estimated code review effort

🎯 5 (Critical) | ⏱️ ~90+ minutes

Possibly related PRs

• prisma/prisma-next#301: Both PRs refactor codec registry/lookup and unify encodeJson/decodeJson, affecting contract emission and type dispatch logic.
• prisma/prisma-next#350: Similar registry/unification: moves trait/meta/render metadata to codec descriptors and refactors registry APIs.
• prisma/prisma-next#379: Directly related: implements Promise-based codec contract and descriptor-driven registry across framework and runtime.

Poem

In fields and columns, codecs now stand tall,
With classes and descriptors uniting all.
Traits, parameters, outputs—organized and bright,
Registry flows mapped in columnar light.
From framework roots to high-level tests,
🐇 All code now dances—in class-form, it rests!
Hop onward, dear stack, into unified quests!

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch tml-2357-codec-registration-model-complete-the-unified

⚔️ Resolve merge conflicts

• Resolve merge conflict in branch tml-2357-codec-registration-model-complete-the-unified

[pkg-pr-new]

Open in StackBlitz

@prisma-next/mongo-runtime

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-runtime@417

@prisma-next/family-mongo

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/family-mongo@417

@prisma-next/sql-runtime

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-runtime@417

@prisma-next/family-sql

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/family-sql@417

@prisma-next/extension-arktype-json

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/extension-arktype-json@417

@prisma-next/middleware-telemetry

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/middleware-telemetry@417

@prisma-next/mongo

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo@417

@prisma-next/extension-paradedb

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/extension-paradedb@417

@prisma-next/extension-pgvector

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/extension-pgvector@417

@prisma-next/postgres

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/postgres@417

@prisma-next/sql-orm-client

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-orm-client@417

@prisma-next/sqlite

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sqlite@417

@prisma-next/target-mongo

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/target-mongo@417

@prisma-next/adapter-mongo

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/adapter-mongo@417

@prisma-next/driver-mongo

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/driver-mongo@417

@prisma-next/contract

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/contract@417

@prisma-next/utils

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/utils@417

@prisma-next/config

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/config@417

@prisma-next/errors

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/errors@417

@prisma-next/framework-components

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/framework-components@417

@prisma-next/operations

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/operations@417

@prisma-next/ts-render

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/ts-render@417

@prisma-next/contract-authoring

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/contract-authoring@417

@prisma-next/ids

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/ids@417

@prisma-next/psl-parser

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/psl-parser@417

@prisma-next/psl-printer

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/psl-printer@417

@prisma-next/cli

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/cli@417

@prisma-next/emitter

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/emitter@417

@prisma-next/migration-tools

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/migration-tools@417

prisma-next

npm i https://pkg.pr.new/prisma/prisma-next@417

@prisma-next/vite-plugin-contract-emit

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/vite-plugin-contract-emit@417

@prisma-next/mongo-codec

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-codec@417

@prisma-next/mongo-contract

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-contract@417

@prisma-next/mongo-value

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-value@417

@prisma-next/mongo-contract-psl

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-contract-psl@417

@prisma-next/mongo-contract-ts

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-contract-ts@417

@prisma-next/mongo-emitter

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-emitter@417

@prisma-next/mongo-schema-ir

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-schema-ir@417

@prisma-next/mongo-query-ast

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-query-ast@417

@prisma-next/mongo-orm

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-orm@417

@prisma-next/mongo-query-builder

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-query-builder@417

@prisma-next/mongo-lowering

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-lowering@417

@prisma-next/mongo-wire

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/mongo-wire@417

@prisma-next/sql-contract

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-contract@417

@prisma-next/sql-errors

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-errors@417

@prisma-next/sql-operations

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-operations@417

@prisma-next/sql-schema-ir

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-schema-ir@417

@prisma-next/sql-contract-psl

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-contract-psl@417

@prisma-next/sql-contract-ts

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-contract-ts@417

@prisma-next/sql-contract-emitter

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-contract-emitter@417

@prisma-next/sql-lane-query-builder

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-lane-query-builder@417

@prisma-next/sql-relational-core

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-relational-core@417

@prisma-next/sql-builder

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/sql-builder@417

@prisma-next/target-postgres

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/target-postgres@417

@prisma-next/target-sqlite

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/target-sqlite@417

@prisma-next/adapter-postgres

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/adapter-postgres@417

@prisma-next/adapter-sqlite

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/adapter-sqlite@417

@prisma-next/driver-postgres

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/driver-postgres@417

@prisma-next/driver-sqlite

npm i https://pkg.pr.new/prisma/prisma-next/@prisma-next/driver-sqlite@417

commit: 692178c

[coderabbitai]

Actionable comments posted: 13

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

packages/2-sql/5-runtime/src/sql-context.ts (1)

493-516: ⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

Don't collapse non-parameterized column codecs to one instance per codecId.

CodecInstanceContext is per materialization site, but this cache makes contractCodecs.forColumn() hand back the same codec instance for every column sharing a non-parameterized id. The first column wins the captured ctx.name / usedAt, so any non-parameterized codec that derives state from column context will behave incorrectly.

🛠️ Safer materialization shape

         } else if (!isParameterized) {
-          let cached = byCodecId.get(column.codecId);
-          if (!cached) {
-            const ctx: SqlCodecInstanceContext = {
-              name: `<shared:${column.codecId}>`,
-              usedAt: [{ table: tableName, column: columnName }],
-            };
-            const voidFactory = descriptor.factory as unknown as (
-              params: undefined,
-            ) => (ctx: SqlCodecInstanceContext) => Codec;
-            cached = voidFactory(undefined)(ctx);
-            byCodecId.set(column.codecId, cached);
-          }
-          resolvedCodec = cached;
+          const ctx: SqlCodecInstanceContext = {
+            name: `<anon:${tableName}.${columnName}>`,
+            usedAt: [{ table: tableName, column: columnName }],
+          };
+          const voidFactory = descriptor.factory as unknown as (
+            params: undefined,
+          ) => (ctx: SqlCodecInstanceContext) => Codec;
+          resolvedCodec = voidFactory(undefined)(ctx);
+          byCodecId.set(column.codecId, byCodecId.get(column.codecId) ?? resolvedCodec);
         }

If you still want a codec-id fallback, keep that representative instance separate from the per-column instances rather than reusing the column-scoped object for every site.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/2-sql/5-runtime/src/sql-context.ts` around lines 493 - 516, The code
currently caches the concrete Codec instance in byCodecId (via
voidFactory(undefined)(ctx)), causing every non-parameterized column to share
the same instance and captured ctx; instead cache the parameterless factory
function and invoke it per-column so each materialization site gets its own
Codec with its own SqlCodecInstanceContext. Concretely: in the branch that
handles non-parameterized codecs (where descriptor.factory is cast to
voidFactory), store the function returned by voidFactory(undefined) in byCodecId
(not the result of calling it with ctx), then for each column call that cached
factory with a fresh SqlCodecInstanceContext to produce resolvedCodec; update
uses of cached/voidFactory/byCodecId/resolvedCodec accordingly so
contractCodecs.forColumn() returns per-column instances.

🧹 Nitpick comments (7)

examples/prisma-next-demo/test/no-emit-typed-flow.test-d.ts (1)

20-22: ⚡ Quick win

Use package-export imports in this example test

Line 20 and Line 21 import internals via relative paths. For examples/**/test/**, this should validate the public API surface by importing from package exports (@prisma-next/...) instead.

As per coding guidelines, “Cross-package and integration tests: Import from package exports (@prisma-next/...) to verify the public API.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@examples/prisma-next-demo/test/no-emit-typed-flow.test-d.ts` around lines 20
- 22, The test imports package internals via relative paths; update the imports
to use the package-export public API instead: replace the relative imports that
bring in the types/symbols "contract" and "sql" with their corresponding
exported package paths so the test validates the public surface (import the
"contract" type and the "sql" helper from the package exports for
prisma/prisma-no-emit rather than from ../prisma/contract and
../src/prisma-no-emit/context).

packages/2-sql/4-lanes/relational-core/test/utils.ts (1)

4-11: ⚡ Quick win

Avoid /exports/ barrel imports in this test utility.

Line 10 and Line 11 import through ../src/exports/*; switch these to direct module imports to keep dependency boundaries explicit.

As per coding guidelines: “Avoid barrel files for exports; use direct file imports instead” and “Import from shared plane packages using package name and export identifier … not /exports/ paths.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/2-sql/4-lanes/relational-core/test/utils.ts` around lines 4 - 11,
The test utility currently imports Adapter, Codec, CodecRegistry,
LoweredStatement, SelectAst and ExecutionContext from barrel paths
('../src/exports/*'); change these to import the same symbols directly from
their concrete modules (the specific source files that define Adapter, Codec,
CodecRegistry, LoweredStatement, SelectAst and ExecutionContext) so you avoid
`/exports/` barrel imports and keep dependency boundaries explicit; update the
import statements to reference the original modules that declare those types and
remove the barrel paths.

packages/3-targets/3-targets/postgres/src/core/codecs.ts (1)

55-72: 💤 Low value

Redundant undefined check for precision parameter.

The function parameter declares precision as readonly precision: number (required), but line 60 checks if (precision === undefined). This check is unreachable given the type signature.

If precision can actually be undefined at runtime (e.g., from untyped callers), consider changing the type to readonly precision?: number. Otherwise, remove the redundant check.

♻️ Suggested fix if precision is guaranteed

 export const pgNumericRenderOutputType = (typeParams: {
   readonly precision: number;
   readonly scale?: number;
 }): string | undefined => {
   const precision = typeParams.precision;
-  if (precision === undefined) return undefined;
   if (
     typeof precision !== 'number' ||
     !Number.isFinite(precision) ||
     !Number.isInteger(precision)
   ) {

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/postgres/src/core/codecs.ts` around lines 55 -
72, The check for precision being undefined in pgNumericRenderOutputType is
unreachable because typeParams declares readonly precision: number; remove the
if (precision === undefined) return undefined; branch and any related
early-return logic; alternatively, if precision can be missing at runtime,
change the signature to readonly precision?: number and keep the check —
reference the function name pgNumericRenderOutputType and the property
typeParams.precision when making the change.

packages/2-sql/2-authoring/contract-psl/test/fixtures.ts (1)

160-164: ⚡ Quick win

Harden codec-id presence checks with Object.hasOwn.

Line 160 and Line 163 currently rely on plain index lookups, which can accidentally treat prototype keys (for example, "constructor") as valid codec ids.

Suggested patch

 export const postgresCodecLookup: CodecLookup = {
   get: (id: string) => {
-    if (!targetTypesByCodecId[id]) return undefined;
+    if (!Object.hasOwn(targetTypesByCodecId, id)) return undefined;
     return { id } as ReturnType<CodecLookup['get']>;
   },
-  targetTypesFor: (id: string) => targetTypesByCodecId[id],
+  targetTypesFor: (id: string) =>
+    Object.hasOwn(targetTypesByCodecId, id) ? targetTypesByCodecId[id] : undefined,
   metaFor: () => undefined,
   renderOutputTypeFor: () => undefined,
 };

As per coding guidelines "Always use Object.hasOwn() instead of hasOwnProperty() to check for own properties."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/2-sql/2-authoring/contract-psl/test/fixtures.ts` around lines 160 -
164, Replace plain property index checks on targetTypesByCodecId with
Object.hasOwn to avoid treating prototype keys as valid codec ids: in the
implementation returning ReturnType<CodecLookup['get']> change the existence
check from if (!targetTypesByCodecId[id]) to if
(!Object.hasOwn(targetTypesByCodecId, id)) and in the targetTypesFor method
ensure it only returns targetTypesByCodecId[id] when
Object.hasOwn(targetTypesByCodecId, id) (otherwise return undefined); leave
metaFor as-is.

packages/1-framework/1-core/framework-components/test/codec.types.test-d.ts (1)

249-249: 💤 Low value

Use toExtend instead of deprecated toMatchTypeOf.

Per coding guidelines, toMatchTypeOf() is deprecated in Vitest's expectTypeOf API. Use toExtend<T>() instead.

♻️ Proposed fix

-  expectTypeOf<typeof reg>().toMatchTypeOf<Map<string, AnyCodecDescriptor>>();
+  expectTypeOf<typeof reg>().toExtend<Map<string, AnyCodecDescriptor>>();

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/1-framework/1-core/framework-components/test/codec.types.test-d.ts`
at line 249, Replace the deprecated expectTypeOf(...).toMatchTypeOf usage with
the supported generic toExtend form: locate the assertion using reg
(expectTypeOf<typeof reg>().toMatchTypeOf<Map<string, AnyCodecDescriptor>>())
and change it to use toExtend with the same generic type (expectTypeOf<typeof
reg>().toExtend<Map<string, AnyCodecDescriptor>>()); ensure the generic
parameter remains Map<string, AnyCodecDescriptor> and the assertion target
remains typeof reg.

packages/1-framework/1-core/framework-components/src/shared/column-spec.ts (1)

34-55: ⚡ Quick win

Thread the TCodecId generic through ColumnSpec to preserve codec ID literals in helper return types.

ColumnTypeDescriptor is generic in TCodecId, but ColumnSpec and the column() function drop this parameter. Codec ID literals widen to string at the helper boundary, losing type precision that downstream code (e.g., contract-dsl.ts) already extracts via Descriptor['codecId']. Threading the generic would maintain literal fidelity through the helper surface and align with the field-state pattern used in contract authoring.

♻️ Suggested type-surface fix

-export interface ColumnSpec<R, P extends Record<string, unknown> | undefined>
-  extends ColumnTypeDescriptor {
+export interface ColumnSpec<
+  TCodecId extends string,
+  R,
+  P extends Record<string, unknown> | undefined,
+> extends ColumnTypeDescriptor<TCodecId> {
   readonly codecFactory: (ctx: CodecInstanceContext) => R;
   readonly typeParams: P;
 }

-export function column<R, P extends Record<string, unknown> | undefined>(
+export function column<
+  TCodecId extends string,
+  R,
+  P extends Record<string, unknown> | undefined,
+>(
   codecFactory: (ctx: CodecInstanceContext) => R,
-  codecId: string,
+  codecId: TCodecId,
   typeParams: P,
   nativeType: string,
-): ColumnSpec<R, P> {
+): ColumnSpec<TCodecId, R, P> {
   return {
     codecFactory,
     codecId,
     typeParams,
     nativeType,
   };
 }

 export type ColumnHelperFor<D extends CodecDescriptor<any>> = (
   ...args: any[]
-) => ColumnSpec<unknown, ColumnHelperParams<D>>;
+) => ColumnSpec<D['codecId'], unknown, ColumnHelperParams<D>>;

 export type ColumnHelperForStrict<D extends CodecDescriptor<any>> = (
   ...args: any[]
-) => ColumnSpec<ReturnType<ReturnType<D['factory']>>, ColumnHelperParams<D>>;
+) => ColumnSpec<
+  D['codecId'],
+  ReturnType<ReturnType<D['factory']>>,
+  ColumnHelperParams<D>
+>;

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/1-framework/1-core/framework-components/src/shared/column-spec.ts`
around lines 34 - 55, ColumnSpec currently drops the TCodecId generic from
ColumnTypeDescriptor which widens codecId literals to string; update ColumnSpec
to be generic in TCodecId and extend ColumnTypeDescriptor<TCodecId> (e.g. change
the declaration to something like interface ColumnSpec<TCodecId extends string,
R, P extends Record<string, unknown> | undefined> extends
ColumnTypeDescriptor<TCodecId>), keep the existing codecFactory and typeParams
members but use the P and R generics, and then propagate the TCodecId generic
through the column() helper signature so helper return types preserve codec ID
literals.

packages/3-extensions/sql-orm-client/src/types.ts (1)

302-305: ⚡ Quick win

Use ifDefined() instead of inline conditional object spreads in param().

Line 302-Line 305 currently uses inline spread conditionals; this codepath should use the shared helper for consistency with repo conventions.

As per coding guidelines, "Use ifDefined() from @prisma-next/utils/defined for conditional object spreads instead of inline conditional spread patterns".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-extensions/sql-orm-client/src/types.ts` around lines 302 - 305,
The inline conditional spreads in param() should be replaced with the shared
helper ifDefined from `@prisma-next/utils/defined`: import ifDefined and pass
ParamRef.of(value, ifDefined({ codecId }, { refs })) (or a single ifDefined call
that combines the optional codecId and refs objects) instead of the current
...(codecId !== undefined ? { codecId } : {}), ...(refs !== undefined ? { refs }
: {}); update the param() return to use ifDefined and remove the inline
conditional spreads while keeping ParamRef.of and the same option shape.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@docs/architecture` docs/adrs/ADR 184 - Codec-owned value serialization.md:
- Line 59: The paragraph claims "the defineCodec() factory provides these
defaults" but defineCodec() is retired; update the text that describes
encodeJson/decodeJson to either mark the defineCodec() statement as historical
("historically, defineCodec() provided these defaults") or reword it to the
current authoring surface (e.g., explain that the codec class/descriptor default
implementations make encodeJson/decodeJson identity for JSON-safe types and only
Date/binary codecs override them); do the same for the duplicate instance of
this sentence elsewhere so the ADR is internally consistent.

In `@docs/reference/codec-authoring-guide.md`:
- Around line 262-269: Update the docs' references that point to old filenames
so readers are directed to the new class-style implementations: change mentions
of the pre-migration files (e.g. "sql-codecs.ts" and "codecs.ts") to the
migrated filenames "sql-codecs-class.ts" and "codecs-class.ts" in the paragraphs
that describe the aliasCodec helper, CodecDescriptorImpl<P>, and the alias
factory pattern (around the aliasCodec/CodecDescriptorImpl example); ensure any
other occurrences (including the similar text at lines ~320-331) are updated
consistently so the guide links to the current implementations.

In `@examples/prisma-next-demo/test/no-emit-typed-flow.test-d.ts`:
- Around line 27-32: The test title claims the User.id is a string but current
assertions only check presence; update the test "field.id.uuidv4() produces a
string-typed id field on User" to actually assert the scalar type (or rename the
test to reflect presence-only checks). Specifically, in the test referencing
UserStorageFields and IdField (from (typeof
contract.models)['User']['storage']['fields']), add a type-level assertion that
IdField's column (or the appropriate scalar property on IdField) is string-typed
(e.g., assert IdField['column'] equals string) using expectTypeOf, or change the
test name to remove the "string-typed" claim.

In `@packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts`:
- Around line 67-76: lengthParamsSchema currently requires length but
LengthParams marks it optional and the sqlCharColumn/sqlVarcharColumn helpers
default params to {} which produces descriptors that validateTypeParams later
rejects; either relax lengthParamsSchema to make length optional (change to
'length?') so bare char/varchar is supported, or make LengthParams require
length and stop defaulting params to {} in the helper functions (sqlCharColumn,
sqlVarcharColumn and the other affected helpers mentioned) so callers must
provide length; update validateTypeParams usage accordingly to match the chosen
contract.

In `@packages/2-sql/4-lanes/relational-core/test/utils.ts`:
- Around line 39-41: profile.codecs() currently returns a new empty registry
every call (via emptyCodecRegistry()), causing registered codecs to be lost
between calls; fix by creating a single stable registry instance (e.g., const
codecRegistry = emptyCodecRegistry()) and have profile.codecs() return that same
codecRegistry so registrations persist; update the utils.ts factory that defines
profile.codecs() to initialize the registry once (module-scope or closure) and
return it on each call, leaving emptyCodecRegistry() usage but only invoked
once.

In `@packages/2-sql/5-runtime/src/codecs/encoding.ts`:
- Around line 56-62: When metadata.refs is present the resolution must use the
column path only and must not fall back to id-based resolution; in the block
that checks contractCodecs.forColumn(metadata.refs.table, metadata.refs.column)
(symbols: metadata.refs, contractCodecs, forColumn), change the logic so that if
byColumn is falsy you stop resolution immediately (e.g. return undefined or
throw a clear error) instead of continuing to
contractCodecs.forCodecId(metadata.codecId) or registry.get(metadata.codecId);
this ensures a missing column lookup fails fast rather than downgrading to
codec-id dispatch.

In `@packages/3-extensions/arktype-json/src/core/arktype-json-codec-class.ts`:
- Around line 144-154: Replace the blind cast in rehydrateSchema by adding a
type predicate (e.g. isArktypeSchemaLike) and use it to assert the return of
ark.schema(jsonIr) is an ArktypeSchemaLike before returning; if the predicate
fails throw the same runtimeError (preserving ARKTYPE_JSON_CODEC_ID and jsonIr)
so invalid shapes are rejected instead of being force-cast; keep the existing
try/catch and error message behavior around ark.schema and runtimeError.

In `@packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts`:
- Around line 75-79: The test uses an explicit any cast and a biome-ignore;
replace that with a TypeScript compile-time suppression: remove the "as any" and
the biome lint suppression, and instead place a single-line "@ts-expect-error —
intentionally passing non-callable to test runtime guard" immediately above the
arktypeJsonColumn(notASchema) call (leaving notASchema typed as an object), so
the runtime negative-path assertion remains but the test follows the repo rule
against any/biome ignores; target the arktypeJsonColumn call in
arktype-json-codec-class.test.ts when making this change.

In
`@packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts`:
- Around line 140-142: The type-test assertion for variable col uses the
deprecated matcher toMatchTypeOf; update the expectTypeOf(col) call to use
toExtend with the same generic target type ColumnSpec<ArktypeJsonCodecClass<{
name: string; price: number }>, ArktypeJsonTypeParams> so the assertion reads
expectTypeOf(col).toExtend<...>(), keeping the same generics (ColumnSpec,
ArktypeJsonCodecClass, ArktypeJsonTypeParams) and not changing the tested
variable name col.

In `@packages/3-extensions/sql-orm-client/src/types.ts`:
- Around line 292-294: refsFromLeft currently only handles kind === 'column-ref'
which drops refs for other AnyExpression shapes (so result.buildAst() loses refs
and breaks codec dispatch); update refsFromLeft (and the comparison factory
usage that passes result.buildAst()) to preserve/collect refs for any expression
by returning refs found on the expression (e.g., expression.refs if present) or
by recursively extracting column-ref nodes from
BinaryExpr/Unary/Identifier/Literal wrappers so column refs are not lost (keep
the return type { table: string; column: string } | undefined or adjust to
return refs array if needed and update callers accordingly); also replace the
inline conditional spreads in param() that do ...(codecId !== undefined ? {
codecId } : {}) and ...(refs !== undefined ? { refs } : {}) with the ifDefined()
helper from '@prisma-next/utils/defined' (add the import) to follow the
repository guideline.

In `@packages/3-targets/3-targets/postgres/src/core/codecs-class.ts`:
- Around line 110-126: The TypeScript type LengthParams marks length as optional
but lengthParamsSchema requires it, causing runtime validation failures when
helpers (e.g., pgBitColumn) pass {} as params; update lengthParamsSchema to make
length optional (change the schema key to 'length?' with the same constraint) so
the runtime arktype matches the LengthParams type and existing callers that
default params = {} continue to validate correctly.

In `@packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts`:
- Around line 250-264: The decode paths (async decode and decodeJson) and the
encoder path (encode and encodeJson) should validate Date objects: after
constructing a Date in decode/decodeJson, check that date.getTime() is not NaN
and throw a TypeError (same contract message) for malformed/invalid ISO strings;
in encode/encodeJson ensure the provided Date is valid (check
isFinite(date.getTime()) or !isNaN) and throw TypeError if it is an Invalid Date
before calling toISOString; update the functions named encode, decode,
encodeJson, and decodeJson in codecs-class.ts accordingly.

---

Outside diff comments:
In `@packages/2-sql/5-runtime/src/sql-context.ts`:
- Around line 493-516: The code currently caches the concrete Codec instance in
byCodecId (via voidFactory(undefined)(ctx)), causing every non-parameterized
column to share the same instance and captured ctx; instead cache the
parameterless factory function and invoke it per-column so each materialization
site gets its own Codec with its own SqlCodecInstanceContext. Concretely: in the
branch that handles non-parameterized codecs (where descriptor.factory is cast
to voidFactory), store the function returned by voidFactory(undefined) in
byCodecId (not the result of calling it with ctx), then for each column call
that cached factory with a fresh SqlCodecInstanceContext to produce
resolvedCodec; update uses of cached/voidFactory/byCodecId/resolvedCodec
accordingly so contractCodecs.forColumn() returns per-column instances.

---

Nitpick comments:
In `@examples/prisma-next-demo/test/no-emit-typed-flow.test-d.ts`:
- Around line 20-22: The test imports package internals via relative paths;
update the imports to use the package-export public API instead: replace the
relative imports that bring in the types/symbols "contract" and "sql" with their
corresponding exported package paths so the test validates the public surface
(import the "contract" type and the "sql" helper from the package exports for
prisma/prisma-no-emit rather than from ../prisma/contract and
../src/prisma-no-emit/context).

In `@packages/1-framework/1-core/framework-components/src/shared/column-spec.ts`:
- Around line 34-55: ColumnSpec currently drops the TCodecId generic from
ColumnTypeDescriptor which widens codecId literals to string; update ColumnSpec
to be generic in TCodecId and extend ColumnTypeDescriptor<TCodecId> (e.g. change
the declaration to something like interface ColumnSpec<TCodecId extends string,
R, P extends Record<string, unknown> | undefined> extends
ColumnTypeDescriptor<TCodecId>), keep the existing codecFactory and typeParams
members but use the P and R generics, and then propagate the TCodecId generic
through the column() helper signature so helper return types preserve codec ID
literals.

In `@packages/1-framework/1-core/framework-components/test/codec.types.test-d.ts`:
- Line 249: Replace the deprecated expectTypeOf(...).toMatchTypeOf usage with
the supported generic toExtend form: locate the assertion using reg
(expectTypeOf<typeof reg>().toMatchTypeOf<Map<string, AnyCodecDescriptor>>())
and change it to use toExtend with the same generic type (expectTypeOf<typeof
reg>().toExtend<Map<string, AnyCodecDescriptor>>()); ensure the generic
parameter remains Map<string, AnyCodecDescriptor> and the assertion target
remains typeof reg.

In `@packages/2-sql/2-authoring/contract-psl/test/fixtures.ts`:
- Around line 160-164: Replace plain property index checks on
targetTypesByCodecId with Object.hasOwn to avoid treating prototype keys as
valid codec ids: in the implementation returning ReturnType<CodecLookup['get']>
change the existence check from if (!targetTypesByCodecId[id]) to if
(!Object.hasOwn(targetTypesByCodecId, id)) and in the targetTypesFor method
ensure it only returns targetTypesByCodecId[id] when
Object.hasOwn(targetTypesByCodecId, id) (otherwise return undefined); leave
metaFor as-is.

In `@packages/2-sql/4-lanes/relational-core/test/utils.ts`:
- Around line 4-11: The test utility currently imports Adapter, Codec,
CodecRegistry, LoweredStatement, SelectAst and ExecutionContext from barrel
paths ('../src/exports/*'); change these to import the same symbols directly
from their concrete modules (the specific source files that define Adapter,
Codec, CodecRegistry, LoweredStatement, SelectAst and ExecutionContext) so you
avoid `/exports/` barrel imports and keep dependency boundaries explicit; update
the import statements to reference the original modules that declare those types
and remove the barrel paths.

In `@packages/3-extensions/sql-orm-client/src/types.ts`:
- Around line 302-305: The inline conditional spreads in param() should be
replaced with the shared helper ifDefined from `@prisma-next/utils/defined`:
import ifDefined and pass ParamRef.of(value, ifDefined({ codecId }, { refs }))
(or a single ifDefined call that combines the optional codecId and refs objects)
instead of the current ...(codecId !== undefined ? { codecId } : {}), ...(refs
!== undefined ? { refs } : {}); update the param() return to use ifDefined and
remove the inline conditional spreads while keeping ParamRef.of and the same
option shape.

In `@packages/3-targets/3-targets/postgres/src/core/codecs.ts`:
- Around line 55-72: The check for precision being undefined in
pgNumericRenderOutputType is unreachable because typeParams declares readonly
precision: number; remove the if (precision === undefined) return undefined;
branch and any related early-return logic; alternatively, if precision can be
missing at runtime, change the signature to readonly precision?: number and keep
the check — reference the function name pgNumericRenderOutputType and the
property typeParams.precision when making the change.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yml

Review profile: CHILL

Plan: Pro

Run ID: 69fcb105-9c82-4733-9268-a3018eb3c54d

📥 Commits

Reviewing files that changed from the base of the PR and between 1d8b709 and 2d4eb3b.

⛔ Files ignored due to path filters (6)

• pnpm-lock.yaml is excluded by !**/pnpm-lock.yaml
• projects/codec-registration-completion/plan.md is excluded by !projects/**
• projects/codec-registration-completion/spec.md is excluded by !projects/**
• projects/codec-registration-completion/specs/class-based-codec-design.spec.md is excluded by !projects/**
• projects/codec-registration-completion/specs/factory-defined-codec-types.spec.md is excluded by !projects/**
• projects/codec-registration-completion/specs/typed-codec-flow.spec.md is excluded by !projects/**

📒 Files selected for processing (218)

• docs/README.md
• docs/Testing Guide.md
• docs/architecture docs/adrs/ADR 152 - Execution Plane Descriptors and Instances.md
• docs/architecture docs/adrs/ADR 184 - Codec-owned value serialization.md
• docs/architecture docs/adrs/ADR 186 - Codec-dispatched type rendering.md
• docs/architecture docs/adrs/ADR 202 - Codec trait system.md
• docs/architecture docs/adrs/ADR 204 - Single-Path Async Codec Runtime.md
• docs/architecture docs/adrs/ADR 205 - SQL cast emission is adapter policy.md
• docs/architecture docs/adrs/ADR 207 - Codec call context per-query AbortSignal and column metadata.md
• docs/architecture docs/adrs/ADR 208 - Higher-order codecs for parameterized types.md
• docs/architecture docs/adrs/ADR 209 - Mongo result-shape as a structural plan field.md
• docs/architecture docs/subsystems/2. Contract Emitter & Types.md
• docs/reference/codec-authoring-guide.md
• docs/reference/community-generator-migration-analysis.md
• docs/reference/framework-gaps.md
• docs/reference/typescript-patterns.md
• examples/prisma-next-demo/test/no-emit-typed-flow.test-d.ts
• packages/1-framework/0-foundation/contract/package.json
• packages/1-framework/0-foundation/contract/src/exports/types.ts
• packages/1-framework/0-foundation/contract/src/standard-schema-utils.ts
• packages/1-framework/1-core/framework-components/README.md
• packages/1-framework/1-core/framework-components/src/control/control-stack.ts
• packages/1-framework/1-core/framework-components/src/exports/codec.ts
• packages/1-framework/1-core/framework-components/src/shared/codec-descriptor.ts
• packages/1-framework/1-core/framework-components/src/shared/codec-types.ts
• packages/1-framework/1-core/framework-components/src/shared/codec.ts
• packages/1-framework/1-core/framework-components/src/shared/column-spec.ts
• packages/1-framework/1-core/framework-components/src/shared/framework-components.ts
• packages/1-framework/1-core/framework-components/test/codec-call-context.types.test-d.ts
• packages/1-framework/1-core/framework-components/test/codec-types.types.test-d.ts
• packages/1-framework/1-core/framework-components/test/codec.test.ts
• packages/1-framework/1-core/framework-components/test/codec.types.test-d.ts
• packages/1-framework/1-core/framework-components/test/control-stack.test.ts
• packages/1-framework/2-authoring/contract/README.md
• packages/1-framework/2-authoring/contract/src/descriptors.ts
• packages/1-framework/2-authoring/contract/src/index.ts
• packages/1-framework/2-authoring/contract/test/descriptors.test.ts
• packages/1-framework/2-authoring/ids/package.json
• packages/1-framework/2-authoring/ids/src/index.ts
• packages/1-framework/3-tooling/cli/src/control-api/contract-enrichment.ts
• packages/1-framework/3-tooling/cli/test/config-types.test.ts
• packages/1-framework/3-tooling/cli/test/control-api/contract-enrichment.test.ts
• packages/1-framework/3-tooling/emitter/src/domain-type-generation.ts
• packages/1-framework/3-tooling/emitter/test/domain-type-generation.test.ts
• packages/2-mongo-family/1-foundation/mongo-codec/README.md
• packages/2-mongo-family/1-foundation/mongo-codec/src/codec-registry.ts
• packages/2-mongo-family/1-foundation/mongo-codec/src/codecs.ts
• packages/2-mongo-family/1-foundation/mongo-codec/src/exports/index.ts
• packages/2-mongo-family/1-foundation/mongo-codec/test/codecs-ctx.test-d.ts
• packages/2-mongo-family/1-foundation/mongo-codec/test/codecs-ctx.test.ts
• packages/2-mongo-family/1-foundation/mongo-codec/test/codecs.test-d.ts
• packages/2-mongo-family/1-foundation/mongo-codec/test/codecs.test.ts
• packages/2-mongo-family/2-authoring/contract-psl/src/derive-json-schema.ts
• packages/2-mongo-family/2-authoring/contract-psl/test/derive-json-schema.test.ts
• packages/2-mongo-family/2-authoring/contract-psl/test/interpreter.polymorphism.test.ts
• packages/2-mongo-family/2-authoring/contract-psl/test/interpreter.test.ts
• packages/2-mongo-family/7-runtime/README.md
• packages/2-mongo-family/7-runtime/src/mongo-execution-stack.ts
• packages/2-mongo-family/7-runtime/test/codecs/decoding.test.ts
• packages/2-mongo-family/7-runtime/test/decode.integration.test.ts
• packages/2-mongo-family/7-runtime/test/mongo-execution-stack.test.ts
• packages/2-mongo-family/7-runtime/test/mongo-middleware.test.ts
• packages/2-mongo-family/7-runtime/test/mongo-runtime-abort.test.ts
• packages/2-sql/2-authoring/contract-psl/src/provider.ts
• packages/2-sql/2-authoring/contract-psl/test/fixtures.ts
• packages/2-sql/2-authoring/contract-psl/test/provider.test.ts
• packages/2-sql/2-authoring/contract-psl/test/ts-psl-parity.test.ts
• packages/2-sql/2-authoring/contract-ts/src/contract-definition.ts
• packages/2-sql/2-authoring/contract-ts/src/contract-dsl.ts
• packages/2-sql/2-authoring/contract-ts/src/contract-lowering.ts
• packages/2-sql/2-authoring/contract-ts/test/config-types.test.ts
• packages/2-sql/2-authoring/contract-ts/test/contract-builder.contract-definition.test.ts
• packages/2-sql/2-authoring/contract-ts/test/contract-builder.value-objects.test.ts
• packages/2-sql/2-authoring/contract-ts/test/helpers/column-descriptor.ts
• packages/2-sql/3-tooling/emitter/test/emitter-hook.typeref-resolver.test.ts
• packages/2-sql/4-lanes/relational-core/README.md
• packages/2-sql/4-lanes/relational-core/package.json
• packages/2-sql/4-lanes/relational-core/src/ast/codec-types.ts
• packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts
• packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs.ts
• packages/2-sql/4-lanes/relational-core/src/ast/types.ts
• packages/2-sql/4-lanes/relational-core/src/ast/validate-param-refs.ts
• packages/2-sql/4-lanes/relational-core/src/exports/ast.ts
• packages/2-sql/4-lanes/relational-core/src/expression.ts
• packages/2-sql/4-lanes/relational-core/src/query-lane-context.ts
• packages/2-sql/4-lanes/relational-core/test/ast/codec-factory-ctx.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/codec-factory-ctx.types.test-d.ts
• packages/2-sql/4-lanes/relational-core/test/ast/codec-factory.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/codec-factory.types.test-d.ts
• packages/2-sql/4-lanes/relational-core/test/ast/codec-types.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/refs-propagation.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/sql-codecs-class.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/sql-codecs-class.types.test-d.ts
• packages/2-sql/4-lanes/relational-core/test/ast/sql-codecs.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/test-codec.ts
• packages/2-sql/4-lanes/relational-core/test/ast/test-helpers.ts
• packages/2-sql/4-lanes/relational-core/test/ast/validate-param-refs.test.ts
• packages/2-sql/4-lanes/relational-core/test/expression.test.ts
• packages/2-sql/4-lanes/relational-core/test/typed-codec-flow.test-d.ts
• packages/2-sql/4-lanes/relational-core/test/utils.ts
• packages/2-sql/4-lanes/sql-builder/src/runtime/builder-base.ts
• packages/2-sql/4-lanes/sql-builder/src/runtime/expression-impl.ts
• packages/2-sql/4-lanes/sql-builder/src/runtime/field-proxy.ts
• packages/2-sql/4-lanes/sql-builder/src/runtime/functions.ts
• packages/2-sql/4-lanes/sql-builder/src/runtime/mutation-impl.ts
• packages/2-sql/4-lanes/sql-builder/test/runtime/field-proxy.test.ts
• packages/2-sql/4-lanes/sql-builder/test/runtime/functions.test.ts
• packages/2-sql/5-runtime/src/codecs/decoding.ts
• packages/2-sql/5-runtime/src/codecs/encoding.ts
• packages/2-sql/5-runtime/src/codecs/json-schema-validation.ts
• packages/2-sql/5-runtime/src/sql-context.ts
• packages/2-sql/5-runtime/src/sql-runtime.ts
• packages/2-sql/5-runtime/test/before-compile-chain.test.ts
• packages/2-sql/5-runtime/test/codec-async.test.ts
• packages/2-sql/5-runtime/test/codec-decode-ctx.test.ts
• packages/2-sql/5-runtime/test/codec-encode-ctx.test.ts
• packages/2-sql/5-runtime/test/contract-codec-registry.test.ts
• packages/2-sql/5-runtime/test/encoding-dispatch.test.ts
• packages/2-sql/5-runtime/test/execution-stack.test.ts
• packages/2-sql/5-runtime/test/json-schema-validation.test.ts
• packages/2-sql/5-runtime/test/mutation-default-generators.test.ts
• packages/2-sql/5-runtime/test/parameterized-types.test.ts
• packages/2-sql/5-runtime/test/seeded-secret-codec.ts
• packages/2-sql/5-runtime/test/sql-context.test.ts
• packages/2-sql/5-runtime/test/sql-runtime-abort.test.ts
• packages/2-sql/5-runtime/test/sql-runtime.test.ts
• packages/2-sql/5-runtime/test/test-codec.ts
• packages/2-sql/5-runtime/test/utils.ts
• packages/3-extensions/arktype-json/README.md
• packages/3-extensions/arktype-json/src/core/arktype-json-codec-class.ts
• packages/3-extensions/arktype-json/src/core/arktype-json-codec.ts
• packages/3-extensions/arktype-json/src/core/pack-meta.ts
• packages/3-extensions/arktype-json/src/exports/codecs.ts
• packages/3-extensions/arktype-json/src/exports/column-types.ts
• packages/3-extensions/arktype-json/src/exports/control.ts
• packages/3-extensions/arktype-json/src/exports/runtime.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec.test-d.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec.test.ts
• packages/3-extensions/arktype-json/test/extension-descriptors.test.ts
• packages/3-extensions/pgvector/src/core/codecs-class.ts
• packages/3-extensions/pgvector/src/core/codecs.ts
• packages/3-extensions/pgvector/src/core/descriptor-meta.ts
• packages/3-extensions/pgvector/src/exports/column-types.ts
• packages/3-extensions/pgvector/src/exports/runtime.ts
• packages/3-extensions/pgvector/src/types/codec-types.ts
• packages/3-extensions/pgvector/test/codec-render-output-type.test.ts
• packages/3-extensions/pgvector/test/codecs-class.types.test-d.ts
• packages/3-extensions/pgvector/test/codecs.test.ts
• packages/3-extensions/pgvector/test/operations.test.ts
• packages/3-extensions/pgvector/test/typed-descriptor-flow.test-d.ts
• packages/3-extensions/sql-orm-client/src/query-plan-mutations.ts
• packages/3-extensions/sql-orm-client/src/types.ts
• packages/3-extensions/sql-orm-client/src/where-binding.ts
• packages/3-extensions/sql-orm-client/test/codec-async.types.test-d.ts
• packages/3-extensions/sql-orm-client/test/filters.test.ts
• packages/3-extensions/sql-orm-client/test/integration/codec-async.test.ts
• packages/3-extensions/sql-orm-client/test/integration/create.test.ts
• packages/3-extensions/sql-orm-client/test/model-accessor.test.ts
• packages/3-extensions/sql-orm-client/test/query-plan-mutations.test.ts
• packages/3-extensions/sql-orm-client/test/repository.test.ts
• packages/3-extensions/sql-orm-client/test/rich-filters-and-where.test.ts
• packages/3-extensions/sql-orm-client/test/test-codec.ts
• packages/3-mongo-target/1-mongo-target/src/exports/runtime.ts
• packages/3-mongo-target/2-mongo-adapter/src/core/codecs.ts
• packages/3-mongo-target/2-mongo-adapter/src/exports/control.ts
• packages/3-mongo-target/2-mongo-adapter/src/exports/runtime.ts
• packages/3-mongo-target/2-mongo-adapter/test/codecs.test.ts
• packages/3-mongo-target/2-mongo-adapter/test/lowering.test.ts
• packages/3-mongo-target/2-mongo-adapter/test/mongo-adapter-ctx.test.ts
• packages/3-mongo-target/2-mongo-adapter/test/mongo-adapter.test.ts
• packages/3-mongo-target/2-mongo-adapter/test/resolve-value-ctx.test.ts
• packages/3-mongo-target/2-mongo-adapter/test/resolve-value.test.ts
• packages/3-targets/3-targets/postgres/package.json
• packages/3-targets/3-targets/postgres/src/core/codecs-class.ts
• packages/3-targets/3-targets/postgres/src/core/codecs.ts
• packages/3-targets/3-targets/postgres/src/core/descriptor-meta.ts
• packages/3-targets/3-targets/postgres/src/exports/codec-types.ts
• packages/3-targets/3-targets/postgres/src/exports/codecs.ts
• packages/3-targets/3-targets/postgres/src/exports/runtime.ts
• packages/3-targets/3-targets/postgres/test/codec-render-output-type.test.ts
• packages/3-targets/3-targets/postgres/test/codecs-class.test.ts
• packages/3-targets/3-targets/postgres/test/codecs-class.types.test-d.ts
• packages/3-targets/3-targets/postgres/test/codecs.test.ts
• packages/3-targets/3-targets/postgres/test/typed-descriptor-flow.test-d.ts
• packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts
• packages/3-targets/3-targets/sqlite/src/core/codecs.ts
• packages/3-targets/3-targets/sqlite/src/core/descriptor-meta.ts
• packages/3-targets/3-targets/sqlite/src/core/runtime-target.ts
• packages/3-targets/3-targets/sqlite/src/exports/codec-types.ts
• packages/3-targets/3-targets/sqlite/src/exports/codecs.ts
• packages/3-targets/3-targets/sqlite/test/codecs-class.types.test-d.ts
• packages/3-targets/3-targets/sqlite/test/typed-descriptor-flow.test-d.ts
• packages/3-targets/6-adapters/postgres/README.md
• packages/3-targets/6-adapters/postgres/src/core/adapter.ts
• packages/3-targets/6-adapters/postgres/src/core/codec-lookup.ts
• packages/3-targets/6-adapters/postgres/src/core/descriptor-meta.ts
• packages/3-targets/6-adapters/postgres/src/core/sql-renderer.ts
• packages/3-targets/6-adapters/postgres/src/exports/column-types.ts
• packages/3-targets/6-adapters/postgres/src/exports/runtime.ts
• packages/3-targets/6-adapters/postgres/test/adapter.test.ts
• packages/3-targets/6-adapters/postgres/test/descriptor-parity.test.ts
• packages/3-targets/6-adapters/postgres/test/sql-renderer.cast-policy.test.ts
• packages/3-targets/6-adapters/postgres/test/test-codec.ts
• packages/3-targets/6-adapters/sqlite/README.md
• packages/3-targets/6-adapters/sqlite/src/core/adapter.ts
• packages/3-targets/6-adapters/sqlite/src/core/runtime-adapter.ts
• packages/3-targets/6-adapters/sqlite/src/exports/codec-types.ts
• packages/3-targets/6-adapters/sqlite/test/codecs.test.ts
• test/integration/test/authoring/parity/ts-psl-parity.real-packs.test.ts
• test/integration/test/contract-builder.test.ts
• test/integration/test/cross-package/cross-family-codec.test.ts
• test/integration/test/cross-package/test-codec.ts
• test/integration/test/mongo/migration-psl-authoring.test.ts
• test/integration/test/pgvector.test.ts
• test/utils/README.md
• test/utils/src/column-descriptors.ts

💤 Files with no reviewable changes (11)

• packages/2-mongo-family/7-runtime/test/decode.integration.test.ts
• packages/2-mongo-family/1-foundation/mongo-codec/test/codecs-ctx.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/codec-types.test.ts
• packages/3-extensions/pgvector/src/core/codecs.ts
• packages/2-sql/5-runtime/src/codecs/json-schema-validation.ts
• packages/3-extensions/arktype-json/src/core/arktype-json-codec.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec.test-d.ts
• packages/1-framework/2-authoring/contract/src/descriptors.ts
• packages/2-mongo-family/1-foundation/mongo-codec/test/codecs-ctx.test-d.ts
• packages/2-sql/5-runtime/test/json-schema-validation.test.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec.test.ts

[coderabbitai]

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Rephrase the identity-default note in current terms.

The retrospective note already says defineCodec() is retired, but these paragraphs still describe its defaults in the present tense. Please restate this in terms of the current class/descriptor authoring surface, or mark it explicitly as historical, so the ADR does not read as internally contradictory.

As per coding guidelines, "**/*.{md,mdx}: Keep docs current (READMEs, rules, links)`."

Also applies to: 136-136

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/architecture` docs/adrs/ADR 184 - Codec-owned value serialization.md at
line 59, The paragraph claims "the defineCodec() factory provides these
defaults" but defineCodec() is retired; update the text that describes
encodeJson/decodeJson to either mark the defineCodec() statement as historical
("historically, defineCodec() provided these defaults") or reword it to the
current authoring surface (e.g., explain that the codec class/descriptor default
implementations make encodeJson/decodeJson identity for JSON-safe types and only
Date/binary codecs override them); do the same for the duplicate instance of
this sentence elsewhere so the ADR is internally consistent.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update the reference implementation paths.

These sections still point readers to pre-migration filenames like sql-codecs.ts and codecs.ts, but the class-form implementations in this PR live under sql-codecs-class.ts / codecs-class.ts. As written, the new guide sends contributors to stale or removed files right after introducing the replacement pattern.

As per coding guidelines, "Keep docs current (READMEs, rules, links)."

Also applies to: 320-331

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/reference/codec-authoring-guide.md` around lines 262 - 269, Update the
docs' references that point to old filenames so readers are directed to the new
class-style implementations: change mentions of the pre-migration files (e.g.
"sql-codecs.ts" and "codecs.ts") to the migrated filenames "sql-codecs-class.ts"
and "codecs-class.ts" in the paragraphs that describe the aliasCodec helper,
CodecDescriptorImpl<P>, and the alias factory pattern (around the
aliasCodec/CodecDescriptorImpl example); ensure any other occurrences (including
the similar text at lines ~320-331) are updated consistently so the guide links
to the current implementations.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Test claim and assertion are misaligned

Line 27 says this verifies a string-typed id, but Line 29–Line 31 only verify property presence (id, column). Please add a concrete type assertion for the id scalar type (or rename the test to match current assertions).

As per coding guidelines, “Avoid tautological tests that only restate fixture input - tests must verify behavior, not mirror object shape passed by the test itself.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@examples/prisma-next-demo/test/no-emit-typed-flow.test-d.ts` around lines 27
- 32, The test title claims the User.id is a string but current assertions only
check presence; update the test "field.id.uuidv4() produces a string-typed id
field on User" to actually assert the scalar type (or rename the test to reflect
presence-only checks). Specifically, in the test referencing UserStorageFields
and IdField (from (typeof contract.models)['User']['storage']['fields']), add a
type-level assertion that IdField's column (or the appropriate scalar property
on IdField) is string-typed (e.g., assert IdField['column'] equals string) using
expectTypeOf, or change the test name to remove the "string-typed" claim.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Don’t treat every factory failure as “parameterized”.

The broad catch {} makes any descriptor construction error look like an expected “needs real params” case. That means a registered codec can disappear from byId, and downstream codecLookup.get() consumers in this file then misclassify it as unregistered. Please narrow this to the expected missing-params path, or track descriptor presence separately instead of using factory success as the registration signal.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Don't default char/varchar params to {} while the schema requires length.

lengthParamsSchema makes length mandatory, but LengthParams marks it optional and both helpers default to {}. That means sqlCharColumn() / sqlVarcharColumn() can successfully build a contract shape that this same descriptor later rejects in validateTypeParams().

🐛 Suggested fix

-type LengthParams = { readonly length?: number };
+type LengthParams = { readonly length: number };

-export const sqlCharColumn = (params: LengthParams = {}) =>
+export const sqlCharColumn = (params: LengthParams) =>
   column(sqlCharDescriptorClass.factory(params), sqlCharDescriptorClass.codecId, params, 'char');

-export const sqlVarcharColumn = (params: LengthParams = {}) =>
+export const sqlVarcharColumn = (params: LengthParams) =>
   column(
     sqlVarcharDescriptorClass.factory(params),
     sqlVarcharDescriptorClass.codecId,
     params,
     'varchar',
   );

If bare char / varchar is intentionally supported, then the schema should be relaxed to match instead of rejecting the helper output later.

Also applies to: 245-246, 290-296

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts` around
lines 67 - 76, lengthParamsSchema currently requires length but LengthParams
marks it optional and the sqlCharColumn/sqlVarcharColumn helpers default params
to {} which produces descriptors that validateTypeParams later rejects; either
relax lengthParamsSchema to make length optional (change to 'length?') so bare
char/varchar is supported, or make LengthParams require length and stop
defaulting params to {} in the helper functions (sqlCharColumn, sqlVarcharColumn
and the other affected helpers mentioned) so callers must provide length; update
validateTypeParams usage accordingly to match the chosen contract.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Avoid any and the Biome suppression in this negative-path test.

This runtime-guard test can use @ts-expect-error instead; the current as any plus biome-ignore violates the repo’s TypeScript/test rules for intentional invalid inputs.

♻️ Suggested cleanup

   it('rejects non-callable schema lookalikes at the call site', () => {
     const notASchema = { foo: 'bar' };
-    // biome-ignore lint/suspicious/noExplicitAny: deliberately malformed input for the call-site guard
-    expect(() => arktypeJsonColumn(notASchema as any)).toThrow(/callable arktype Type/);
+    // `@ts-expect-error` deliberate invalid input for the runtime guard
+    expect(() => arktypeJsonColumn(notASchema)).toThrow(/callable arktype Type/);
   });

As per coding guidelines, "Never use any type", "Never suppress biome lints", and "Use @ts-expect-error with a short reason in tests instead of blanket @ts-ignore."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts`
around lines 75 - 79, The test uses an explicit any cast and a biome-ignore;
replace that with a TypeScript compile-time suppression: remove the "as any" and
the biome lint suppression, and instead place a single-line "@ts-expect-error —
intentionally passing non-callable to test runtime guard" immediately above the
arktypeJsonColumn(notASchema) call (leaving notASchema typed as an object), so
the runtime negative-path assertion remains but the test follows the repo rule
against any/biome ignores; target the arktypeJsonColumn call in
arktype-json-codec-class.test.ts when making this change.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Verify no deprecated matcher usage remains in declaration type tests.
rg -n --glob '**/*.test-d.ts' '\.toMatchTypeOf\s*<'

Repository: prisma/prisma-next

Length of output: 492

---

🏁 Script executed:

cat -n packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts | sed -n '135,145p'

Repository: prisma/prisma-next

Length of output: 540

---

🏁 Script executed:

rg -n 'toMatchTypeOf' packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts

Repository: prisma/prisma-next

Length of output: 101

---

Replace deprecated toMatchTypeOf matcher in this .test-d.ts assertion.

Line 140 uses toMatchTypeOf, which this repo disallows for type tests; use toExtend instead.

Proposed change

-  expectTypeOf(col).toMatchTypeOf<
+  expectTypeOf(col).toExtend<
     ColumnSpec<ArktypeJsonCodecClass<{ name: string; price: number }>, ArktypeJsonTypeParams>
   >();

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	expectTypeOf(col).toMatchTypeOf<
	ColumnSpec<ArktypeJsonCodecClass<{ name: string; price: number }>, ArktypeJsonTypeParams>
	>();
	expectTypeOf(col).toExtend<
	ColumnSpec<ArktypeJsonCodecClass<{ name: string; price: number }>, ArktypeJsonTypeParams>
	>();

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts`
around lines 140 - 142, The type-test assertion for variable col uses the
deprecated matcher toMatchTypeOf; update the expectTypeOf(col) call to use
toExtend with the same generic target type ColumnSpec<ArktypeJsonCodecClass<{
name: string; price: number }>, ArktypeJsonTypeParams> so the assertion reads
expectTypeOf(col).toExtend<...>(), keeping the same generics (ColumnSpec,
ArktypeJsonCodecClass, ArktypeJsonTypeParams) and not changing the tested
variable name col.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Locate comparison factory usage =="
rg -n -C4 "COMPARISON_METHODS_META|scalarComparisonMethod|listComparisonMethod|\\.create\\(" packages/3-extensions/sql-orm-client/src

echo
echo "== Locate method binding call-sites that pass left expressions =="
rg -n -C6 "COMPARISON_METHODS_META\\[|create\\(left|create\\(.*left|buildAst\\(" packages/3-extensions/sql-orm-client/src

echo
echo "== Check whether expression-level refs are plumbed before AST conversion =="
rg -n -C6 "\\.refs\\b|buildAst\\(" packages/3-extensions/sql-orm-client/src packages/2-sql/4-lanes/sql-builder/src

Repository: prisma/prisma-next

Length of output: 44753

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Type definitions and param function =="
sed -n '296,320p' packages/3-extensions/sql-orm-client/src/types.ts

echo
echo "== Check AnyExpression type definition =="
rg -n "type AnyExpression|interface AnyExpression" packages/3-extensions/sql-orm-client/src -A 5

echo
echo "== Check MethodFactory type =="
rg -n "type MethodFactory" packages/3-extensions/sql-orm-client/src -A 3

echo
echo "== Full context around line 184 in model-accessor.ts =="
sed -n '165,190p' packages/3-extensions/sql-orm-client/src/model-accessor.ts

Repository: prisma/prisma-next

Length of output: 7595

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Check AnyExpression definition in sql-relational-core =="
find packages/2-sql -name "*.ts" -type f | xargs rg -l "export.*type AnyExpression|export.*AnyExpression =" | head -1 | xargs cat | head -100

echo
echo "== Check what buildAst() returns (AstExpression type) =="
rg -n "type AstExpression|interface AstExpression" packages/2-sql -A 3 | head -30

echo
echo "== Check Expression interface and its buildAst method =="
rg -n "interface Expression|type Expression" packages/3-extensions/sql-orm-client/src -B 2 -A 5 | grep -A 8 "buildAst"

Repository: prisma/prisma-next

Length of output: 3308

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Find AnyExpression definition directly =="
rg -n "^export type AnyExpression|^type AnyExpression" packages/2-sql -A 1

echo
echo "== Check discriminated union structure =="
rg -n "kind:" packages/2-sql/2-core/ast/src -C 2 | head -80

echo
echo "== Look at ColumnRef and IdentifierRef definitions =="
rg -n "^export class ColumnRef|^export class IdentifierRef" packages/2-sql -A 10 | head -60

echo
echo "== Check Expression interface buildAst signature =="
rg -n "buildAst.*:" packages/3-extensions/sql-orm-client/src -B 2 -A 1 | grep -B 3 -A 1 "buildAst"

Repository: prisma/prisma-next

Length of output: 402

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Get full AnyExpression definition =="
sed -n '1674,1700p' packages/2-sql/4-lanes/relational-core/src/ast/types.ts

echo
echo "== Check ColumnRef structure =="
rg -n "^export class ColumnRef" packages/2-sql -A 15 | head -40

echo
echo "== Check what properties discriminate AnyExpression types =="
rg -n "readonly kind" packages/2-sql/4-lanes/relational-core/src/ast -B 2 | head -60

echo
echo "== Verify line 184 passes AST (not Expression) to factory =="
sed -n '180,190p' packages/3-extensions/sql-orm-client/src/model-accessor.ts

Repository: prisma/prisma-next

Length of output: 6709

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Check if ifDefined is imported in types.ts =="
head -30 packages/3-extensions/sql-orm-client/src/types.ts

echo
echo "== Check ifDefined utility =="
rg -n "export.*ifDefined" packages -A 5

echo
echo "== Look for example usage of ifDefined =="
rg -n "ifDefined" packages/3-extensions/sql-orm-client/src -B 2 -A 2 | head -40

echo
echo "== Check if any other files in this package use inline conditional spreads like param() =="
rg -n "\.\.\.\(" packages/3-extensions/sql-orm-client/src/types.ts | grep -E "undefined.*\?" | head -5

Repository: prisma/prisma-next

Length of output: 1922

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Show param() and paramList() functions completely =="
sed -n '296,316p' packages/3-extensions/sql-orm-client/src/types.ts

echo
echo "== Check if ifDefined is imported or used anywhere in this file =="
grep -n "ifDefined\|from.*utils/defined" packages/3-extensions/sql-orm-client/src/types.ts

echo
echo "== Verify the actual Expression type and buildAst return =="
rg -n "class Expression|buildAst" packages/2-sql/4-lanes/relational-core/src/expression.ts | head -20

echo
echo "== Confirm line 180 actually passes resultAst (AnyExpression) to factory =="
sed -n '176,186p' packages/3-extensions/sql-orm-client/src/model-accessor.ts

Repository: prisma/prisma-next

Length of output: 856

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== Check where buildAst() is called on Expression result =="
sed -n '165,190p' packages/3-extensions/sql-orm-client/src/model-accessor.ts

echo
echo "== Verify that resultAst is indeed passed to meta.create =="
sed -n '180,185p' packages/3-extensions/sql-orm-client/src/model-accessor.ts

echo
echo "== Confirm refsFromLeft logic - only handles column-ref =="
sed -n '292,294p' packages/3-extensions/sql-orm-client/src/types.ts

echo
echo "== Check if result is always guaranteed to be a ColumnRef or simple expression =="
rg -n "result\\.buildAst\\(\\)" packages/3-extensions/sql-orm-client/src/model-accessor.ts -B 5 -A 2

echo
echo "== Check what types of expressions can be returned from impl() =="
rg -n "Expression<ScopeField>" packages/3-extensions/sql-orm-client/src/model-accessor.ts -B 3 | head -40

Repository: prisma/prisma-next

Length of output: 3260

---

Expression results lose refs when compared, and param() uses inline spreads instead of ifDefined() helper.

Line 292 only extracts refs from column-ref kind. When line 184 passes resultAst = result.buildAst() to the comparison factory, that AST can be any AnyExpression type (BinaryExpr, IdentifierRef, LiteralExpr, etc.), not just ColumnRef. Any non-column-ref expression loses refs, causing parameterized codec dispatch to fail and column-aware codec selection to be bypassed.

Additionally, lines 302–305 use inline conditional object spreads instead of the ifDefined() helper:

...(codecId !== undefined ? { codecId } : {}),
...(refs !== undefined ? { refs } : {}),

Use ifDefined() from @prisma-next/utils/defined to follow the repository guideline for conditional object spreads in TypeScript files.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-extensions/sql-orm-client/src/types.ts` around lines 292 - 294,
refsFromLeft currently only handles kind === 'column-ref' which drops refs for
other AnyExpression shapes (so result.buildAst() loses refs and breaks codec
dispatch); update refsFromLeft (and the comparison factory usage that passes
result.buildAst()) to preserve/collect refs for any expression by returning refs
found on the expression (e.g., expression.refs if present) or by recursively
extracting column-ref nodes from BinaryExpr/Unary/Identifier/Literal wrappers so
column refs are not lost (keep the return type { table: string; column: string }
| undefined or adjust to return refs array if needed and update callers
accordingly); also replace the inline conditional spreads in param() that do
...(codecId !== undefined ? { codecId } : {}) and ...(refs !== undefined ? {
refs } : {}) with the ifDefined() helper from '@prisma-next/utils/defined' (add
the import) to follow the repository guideline.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Type vs schema mismatch: LengthParams.length is optional but schema requires it.

LengthParams declares length?: number (optional), but lengthParamsSchema requires length: 'number.integer > 0'. This inconsistency means:

• The TypeScript type allows calling pgBitColumn() with no params
• But runtime validation via paramsSchema would reject {} because length is required

Looking at usage (lines 748, 794), the column helpers default to params = {}, which would fail schema validation if params are validated at materialization time.

Either make length required in the type, or use 'length?': 'number.integer > 0' in the schema.

🔧 Proposed fix — align schema with optional length

 const lengthParamsSchema = arktype({
-  length: 'number.integer > 0',
+  'length?': 'number.integer > 0',
 });

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	const lengthParamsSchema = arktype({
	length: 'number.integer > 0',
	});
	const numericParamsSchema = arktype({
	precision: 'number.integer > 0 & number.integer <= 1000',
	'scale?': 'number.integer >= 0',
	});
	const precisionParamsSchema = arktype({
	'precision?': 'number.integer >= 0 & number.integer <= 6',
	});
	type LengthParams = { readonly length?: number };
	type PrecisionParams = { readonly precision?: number };
	type NumericParams = { readonly precision: number; readonly scale?: number };
	type EnumParams = { readonly values?: readonly unknown[] };
	const lengthParamsSchema = arktype({
	'length?': 'number.integer > 0',
	});
	const numericParamsSchema = arktype({
	precision: 'number.integer > 0 & number.integer <= 1000',
	'scale?': 'number.integer >= 0',
	});
	const precisionParamsSchema = arktype({
	'precision?': 'number.integer >= 0 & number.integer <= 6',
	});
	type LengthParams = { readonly length?: number };
	type PrecisionParams = { readonly precision?: number };
	type NumericParams = { readonly precision: number; readonly scale?: number };
	type EnumParams = { readonly values?: readonly unknown[] };

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/postgres/src/core/codecs-class.ts` around lines
110 - 126, The TypeScript type LengthParams marks length as optional but
lengthParamsSchema requires it, causing runtime validation failures when helpers
(e.g., pgBitColumn) pass {} as params; update lengthParamsSchema to make length
optional (change the schema key to 'length?' with the same constraint) so the
runtime arktype matches the LengthParams type and existing callers that default
params = {} continue to validate correctly.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Reject malformed datetime strings instead of returning Invalid Date.

Both decode paths currently accept any string that new Date(...) can parse structurally, including values that become Invalid Date. That lets bad storage values or contract JSON escape the codec boundary and fail later in less obvious places.

🐛 Suggested validation

   async decode(wire: string, _ctx: CodecCallContext): Promise<Date> {
-    return new Date(wire);
+    const date = new Date(wire);
+    if (Number.isNaN(date.getTime())) {
+      throw new TypeError('sqlite/datetime@1 wire value must be a valid ISO-8601 string');
+    }
+    return date;
   }
   encodeJson(value: Date): JsonValue {
     return value.toISOString();
   }
   decodeJson(json: JsonValue): Date {
     if (typeof json !== 'string') {
       throw new TypeError('sqlite/datetime@1 contract value must be an ISO-8601 string');
     }
-    return new Date(json);
+    const date = new Date(json);
+    if (Number.isNaN(date.getTime())) {
+      throw new TypeError('sqlite/datetime@1 contract value must be a valid ISO-8601 string');
+    }
+    return date;
   }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts` around lines
250 - 264, The decode paths (async decode and decodeJson) and the encoder path
(encode and encodeJson) should validate Date objects: after constructing a Date
in decode/decodeJson, check that date.getTime() is not NaN and throw a TypeError
(same contract message) for malformed/invalid ISO strings; in encode/encodeJson
ensure the provided Date is valid (check isFinite(date.getTime()) or !isNaN) and
throw TypeError if it is an Invalid Date before calling toISOString; update the
functions named encode, decode, encodeJson, and decodeJson in codecs-class.ts
accordingly.

[coderabbitai]

Actionable comments posted: 4

♻️ Duplicate comments (5)

packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts (1)

140-142: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Use the approved matcher for .test-d.ts type compatibility assertions.

Line 140 uses deprecated toMatchTypeOf; switch to toExtend for this subtype-style check.

♻️ Proposed fix

-  expectTypeOf(col).toMatchTypeOf<
+  expectTypeOf(col).toExtend<
     ColumnSpec<ArktypeJsonCodecClass<{ name: string; price: number }>, ArktypeJsonTypeParams>
   >();

#!/bin/bash
# Verify deprecated matcher usage in .test-d.ts files.
rg -n --glob '**/*.test-d.ts' '\.toMatchTypeOf\s*<'

As per coding guidelines, "**/*.test-d.ts: Do not use the deprecated toMatchTypeOf() matcher in Vitest's expectTypeOf API. Use toExtend() instead."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts`
around lines 140 - 142, Replace the deprecated matcher usage: locate the
expectTypeOf assertion that references ColumnSpec<ArktypeJsonCodecClass<{ name:
string; price: number }>, ArktypeJsonTypeParams> (the expectTypeOf(col) line)
and change the matcher from toMatchTypeOf<...>() to toExtend<...>() so the
subtype-style compatibility check uses the approved Vitest matcher for
.test-d.ts files.

packages/3-extensions/arktype-json/src/core/arktype-json-codec-class.ts (1)

144-147: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Replace the double-cast in schema rehydration with a predicate-based narrow.

Line 146 force-casts ark.schema(jsonIr) with as unknown as ArktypeSchemaLike, which bypasses static safety and can mask shape drift.

♻️ Proposed fix

 function rehydrateSchema(jsonIr: object): ArktypeSchemaLike {
   try {
-    return ark.schema(jsonIr) as unknown as ArktypeSchemaLike;
+    const schema = ark.schema(jsonIr);
+    if (!isArktypeSchemaLike(schema)) {
+      throw new Error('Rehydrated schema is not callable with expression metadata');
+    }
+    return schema;
   } catch (error) {
     throw runtimeError(
       'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',
       `Failed to rehydrate arktype schema from contract IR: ${error instanceof Error ? error.message : String(error)}`,
       { codecId: ARKTYPE_JSON_CODEC_ID, jsonIr },
     );
   }
 }

In current Arktype docs/types, what does `ark.schema(jsonIr)` return, and is the return value guaranteed to be callable with an `expression: string` property?

As per coding guidelines, "packages/**/*.{ts,tsx}: No blind casts in production code: as unknown as X is forbidden outside tests. Prefer type predicates or fix the type surface."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-extensions/arktype-json/src/core/arktype-json-codec-class.ts`
around lines 144 - 147, The rehydrateSchema function silently force-casts
ark.schema(jsonIr) to ArktypeSchemaLike with "as unknown as", which violates the
no-blind-casts rule; replace the double-cast with a runtime type-narrow: call
ark.schema(jsonIr) into a local const (no cast), then implement and use a type
predicate/is-check (for example isArktypeSchemaLike) that verifies the returned
value is callable and has the expected shape (e.g., a function and the
"expression" property of type string or other required members), throw a clear
error if the check fails, and only then return the value typed as
ArktypeSchemaLike; reference rehydrateSchema and ark.schema when locating code
to change.

packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts (1)

75-79: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Replace as any + lint suppression with @ts-expect-error in the guard test.

Lines 77-78 currently bypass both typing and lint policy; this negative-path test can express intent without any or biome-ignore.

♻️ Proposed fix

   it('rejects non-callable schema lookalikes at the call site', () => {
     const notASchema = { foo: 'bar' };
-    // biome-ignore lint/suspicious/noExplicitAny: deliberately malformed input for the call-site guard
-    expect(() => arktypeJsonColumn(notASchema as any)).toThrow(/callable arktype Type/);
+    // `@ts-expect-error` -- intentionally passing non-callable value to test runtime guard
+    expect(() => arktypeJsonColumn(notASchema)).toThrow(/callable arktype Type/);
   });

#!/bin/bash
# Verify explicit any and biome suppressions in this test file.
rg -n 'biome-ignore|as any|@ts-expect-error' packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts -C2

As per coding guidelines, "Never use any type", "Never suppress biome lints", and "Use @ts-expect-error with a short reason in tests."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts`
around lines 75 - 79, The test currently silences type + lint rules by using "as
any" and a "biome-ignore" comment; replace that with a TypeScript compile-time
suppression using `@ts-expect-error` plus a short reason above the offending call
to arktypeJsonColumn so the test still asserts the runtime guard without using
any/biome ignores. Locate the failing test in arktype-json-codec-class.test.ts
where arktypeJsonColumn(notASchema as any) is called and remove the "as any"
cast and the biome-ignore, adding a single-line "@ts-expect-error TS-EXPLAIN:
deliberate malformed input to exercise call-site guard" immediately above the
call.

packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts (1)

245-258: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Reject invalid Date values at the codec boundary.

new Date(wire) / new Date(json) can produce an Invalid Date, and toISOString() will also fail if callers hand this codec an invalid Date. Validating here keeps malformed storage values and contract JSON from escaping as poisoned Date instances.

🐛 Minimal validation

 export class SqliteDatetimeCodec extends CodecImpl<
@@
 > {
   async encode(value: Date, _ctx: CodecCallContext): Promise<string> {
+    if (Number.isNaN(value.getTime())) {
+      throw new TypeError('sqlite/datetime@1 input value must be a valid Date');
+    }
     return value.toISOString();
   }
   async decode(wire: string, _ctx: CodecCallContext): Promise<Date> {
-    return new Date(wire);
+    const date = new Date(wire);
+    if (Number.isNaN(date.getTime())) {
+      throw new TypeError('sqlite/datetime@1 wire value must be a valid ISO-8601 string');
+    }
+    return date;
   }
   encodeJson(value: Date): JsonValue {
+    if (Number.isNaN(value.getTime())) {
+      throw new TypeError('sqlite/datetime@1 contract value must be a valid Date');
+    }
     return value.toISOString();
   }
   decodeJson(json: JsonValue): Date {
     if (typeof json !== 'string') {
       throw new TypeError('sqlite/datetime@1 contract value must be an ISO-8601 string');
     }
-    return new Date(json);
+    const date = new Date(json);
+    if (Number.isNaN(date.getTime())) {
+      throw new TypeError('sqlite/datetime@1 contract value must be a valid ISO-8601 string');
+    }
+    return date;
   }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts` around lines
245 - 258, The codec must reject invalid Date instances and non-strings: in
encode and encodeJson (functions encode(value: Date, _ctx: CodecCallContext) and
encodeJson(value: Date)) check that value is a Date (instanceof Date) and that
Number.isFinite(value.getTime())/!Number.isNaN(value.getTime()) before calling
toISOString(), and throw a TypeError if not; in decode and decodeJson
(decode(wire: string, _ctx: CodecCallContext) and decodeJson(json: JsonValue))
ensure the input is a string, construct the Date, then validate the produced
Date with Number.isFinite(date.getTime())/!Number.isNaN(...) and throw a
TypeError for invalid dates instead of returning them.

packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts (1)

67-76: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

sqlCharColumn() / sqlVarcharColumn() still expose an impossible params shape.

lengthParamsSchema requires length, but LengthParams makes it optional and both helpers default to {}. That lets callers build column specs that this same descriptor later rejects during params validation. Either require length end-to-end, or relax the schema if bare char / varchar is intentionally supported.

🐛 Minimal fix

-type LengthParams = { readonly length?: number };
+type LengthParams = { readonly length: number };

-export const sqlCharColumn = (params: LengthParams = {}) =>
+export const sqlCharColumn = (params: LengthParams) =>
   column(sqlCharDescriptor.factory(params), sqlCharDescriptor.codecId, params, 'char');

-export const sqlVarcharColumn = (params: LengthParams = {}) =>
+export const sqlVarcharColumn = (params: LengthParams) =>
   column(sqlVarcharDescriptor.factory(params), sqlVarcharDescriptor.codecId, params, 'varchar');

Also applies to: 245-246, 290-291

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts` around
lines 67 - 76, The params shape is inconsistent: lengthParamsSchema currently
requires length but the TypeScript type LengthParams and the
sqlCharColumn/sqlVarcharColumn helpers treat length as optional and default to
{}. Fix by making the contract consistent — either (A) relax lengthParamsSchema
to allow an optional length (e.g., make the length rule accept undefined or mark
it optional) so it matches LengthParams and the default {} behavior, or (B) make
LengthParams require length and update sqlCharColumn/sqlVarcharColumn to require
callers to supply length (and remove the default {}). Locate and update
lengthParamsSchema, the LengthParams type, and the
sqlCharColumn/sqlVarcharColumn call sites to implement the chosen option so
params validation no longer rejects valid inputs.

🧹 Nitpick comments (4)

packages/3-targets/6-adapters/postgres/src/core/adapter.ts (1)

44-60: ⚡ Quick win

Don’t leave the factory(undefined) invariant implicit.

This block now depends on every descriptor in postgresCodecRegistry being safely materializable without params. That may be true for current builtins, but it is only enforced by comments right now. Please move this through a small helper owned next to postgresCodecRegistry or add a fail-fast assertion here so a future param-sensitive descriptor does not silently instantiate the wrong runtime codec.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/6-adapters/postgres/src/core/adapter.ts` around lines 44 -
60, The code silently calls factory(undefined) for each descriptor from
postgresCodecRegistry when constructing codecRegistry, which assumes every
descriptor is paramless; add a fail-fast check or helper next to
postgresCodecRegistry to enforce/verify that a descriptor is materializable
without params before calling factory(undefined). Concretely, introduce a small
predicate/helper (e.g., isParamlessDescriptor) or add an assertion in the
codecRegistry initializer that inspects the descriptor shape and throws a clear
error if params are required, and then only call (descriptor.factory)(undefined)
(or use the helper) to produce the codec instance; reference codecRegistry,
postgresCodecRegistry, CodecInstanceContext and the current factory(undefined)
usage when making the change.

packages/3-targets/6-adapters/sqlite/src/core/adapter.ts (1)

55-70: 🏗️ Heavy lift

Don't materialize every descriptor with factory(undefined).

sqliteCodecRegistry now includes parameterized SQL descriptors, but this loop hard-casts every factory to accept unknown and instantiates it with undefined. The adapter registry therefore only works for descriptors whose runtime instances happen to ignore params; the first param-sensitive codec added here will be mis-materialized. Please keep this surface descriptor-based, or restrict this fallback registry to descriptors whose params are truly void.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/6-adapters/sqlite/src/core/adapter.ts` around lines 55 -
70, The current codecRegistry eagerly materializes every descriptor by calling
descriptor.factory(undefined), which mis-instantiates parameterized descriptors
from sqliteCodecRegistry; change this to preserve descriptor-based entries and
only instantiate codecs when they are truly parameterless: in the codecRegistry
initialization (and related logic around codecRegistry, sqliteCodecRegistry,
CodecInstanceContext and factory), avoid calling factory(undefined) for all
descriptors—instead detect parameterized descriptors (e.g., via a param-type
flag or factory arity) and either keep the original descriptor in the registry
or only call factory() for descriptors known to accept no params; ensure the
fallback registry only materializes codecs whose params are void so
parameterized codecs remain descriptor-based.

packages/3-targets/3-targets/postgres/test/codecs.test.ts (1)

75-82: ⚡ Quick win

Don't bypass parameterized descriptor factories here.

descriptor.factory(undefined as never) sidesteps the public params contract for character, numeric, timestamp, enum, and the other parameterized descriptors in this table. The suite still checks encode/decode behavior, but it no longer proves those codecs can be constructed through their supported API shape. A small paramsByScalar map, or separate helpers for parameterized vs non-parameterized codecs, would keep these tests aligned with the descriptor-first surface.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/postgres/test/codecs.test.ts` around lines 75 -
82, The helper codecForScalar currently calls descriptor.factory(undefined as
never) which bypasses the public params contract for parameterized descriptors;
change codecForScalar to supply real params for parameterized descriptors (e.g.
via a small paramsByScalar map or conditional helpers) and call
descriptor.factory(params) for those scalars, falling back to
descriptor.factory() or descriptor.factory(undefined) only for true
non-parameterized descriptors so that descriptorByScalar/descriptor.factory and
SYNTH_CTX are exercised via the intended public API shape.

packages/3-targets/3-targets/sqlite/src/exports/codec-types.ts (1)

11-45: ⚡ Quick win

Keep src/exports/codec-types.ts as a thin re-export surface.

codecDescriptorMap and Resolve make this export file a second source of truth for SQLite codec membership. That raises the odds of CodecTypes drifting from the core registry/list when the next codec is added or removed. Please move the map/type derivation into ../core/... and re-export the final alias from here so the public entrypoint stays aligned with the package’s single descriptor source.

♻️ Suggested shape

-import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
-import {
-  sqlCharDescriptor,
-  sqlFloatDescriptor,
-  sqlIntDescriptor,
-  sqlVarcharDescriptor,
-} from '@prisma-next/sql-relational-core/ast';
 import type { JsonValue } from '../core/codecs';
-import {
-  sqliteBigintDescriptor,
-  sqliteBlobDescriptor,
-  sqliteDatetimeDescriptor,
-  sqliteIntegerDescriptor,
-  sqliteJsonDescriptor,
-  sqliteRealDescriptor,
-  sqliteTextDescriptor,
-} from '../core/codecs-class';
-
-const codecDescriptorMap = {
-  char: sqlCharDescriptor,
-  varchar: sqlVarcharDescriptor,
-  int: sqlIntDescriptor,
-  float: sqlFloatDescriptor,
-  text: sqliteTextDescriptor,
-  integer: sqliteIntegerDescriptor,
-  real: sqliteRealDescriptor,
-  blob: sqliteBlobDescriptor,
-  datetime: sqliteDatetimeDescriptor,
-  json: sqliteJsonDescriptor,
-  bigint: sqliteBigintDescriptor,
-} as const;
-
-type Resolve<T> = { readonly [K in keyof T]: { readonly [P in keyof T[K]]: T[K][P] } };
-
-export type CodecTypes = Resolve<ExtractCodecTypes<typeof codecDescriptorMap>>;
+export type { CodecTypes } from '../core/codec-types';
 export type { JsonValue };

As per coding guidelines, packages/**/src/exports/{adapter,codec-types,types}.ts re-export files must re-export from core without adding additional logic.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/2-sql/4-lanes/relational-core/src/codec-descriptor-registry.ts`:
- Around line 31-39: The registry currently overwrites duplicate codecId entries
causing inconsistent state; before calling byId.set(descriptor.codecId, widened)
in the loop over allDescriptors (where widened is cast to AnyDescriptor), check
if byId.has(descriptor.codecId) and throw a clear error (including the
conflicting codecId and descriptor identity) to fail-fast on duplicates; only
proceed to add to byTargetType when the codecId is not already present (so byId
and byTargetType remain consistent and descriptorFor(id) will match target-type
lists).

In `@packages/3-extensions/pgvector/src/core/codecs-class.ts`:
- Around line 82-118: The PgVectorCodec produced by factory() must retain
params.length (the declared dimension) and validate input across all ingress
paths: modify factory() to store the expected length on the PgVectorCodec
instance, add a single reused validator function (used by encode, decode, and
decodeJson) that checks the value is an array of numbers and that its length
equals the stored dimension, and update encodeJson/decodeJson/decode/encode to
call that validator and throw descriptive errors for wrong-dimension or
non-numeric entries; ensure contractCodecs.forColumn(table, column) returns a
codec that enforces the declared vector length rather than ignoring
params.length.

In `@packages/3-targets/3-targets/postgres/src/exports/codec-types.ts`:
- Around line 19-86: The file defines codecDescriptorMap, Resolve, and
CodecTypes inline which violates the export-only rule; move the
codecDescriptorMap, Resolve type helper, and the ExtractCodecTypes processing
into a new or existing module under src/core (e.g., export the computed type
there) and then change src/exports/codec-types.ts to only re-export the public
type (export type { CodecTypes } from '../core/...') so the exports file
contains no computation or logic and only exposes the type symbol CodecTypes.

In `@packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts`:
- Around line 204-211: The encodeJson and decodeJson methods currently use
Node-only Buffer; replace that with a runtime-neutral base64 utility so src/core
stays platform-agnostic: implement or import cross-platform helpers (e.g.,
uint8ArrayToBase64 and base64ToUint8Array) that use Web APIs (atob/btoa or
TextEncoder/TextDecoder) and fall back to Buffer only when necessary, then
update encodeJson(value: Uint8Array) to return uint8ArrayToBase64(value) and
decodeJson(json: JsonValue) to validate string and return
base64ToUint8Array(json); keep the function names encodeJson and decodeJson
unchanged.

---

Duplicate comments:
In `@packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts`:
- Around line 67-76: The params shape is inconsistent: lengthParamsSchema
currently requires length but the TypeScript type LengthParams and the
sqlCharColumn/sqlVarcharColumn helpers treat length as optional and default to
{}. Fix by making the contract consistent — either (A) relax lengthParamsSchema
to allow an optional length (e.g., make the length rule accept undefined or mark
it optional) so it matches LengthParams and the default {} behavior, or (B) make
LengthParams require length and update sqlCharColumn/sqlVarcharColumn to require
callers to supply length (and remove the default {}). Locate and update
lengthParamsSchema, the LengthParams type, and the
sqlCharColumn/sqlVarcharColumn call sites to implement the chosen option so
params validation no longer rejects valid inputs.

In `@packages/3-extensions/arktype-json/src/core/arktype-json-codec-class.ts`:
- Around line 144-147: The rehydrateSchema function silently force-casts
ark.schema(jsonIr) to ArktypeSchemaLike with "as unknown as", which violates the
no-blind-casts rule; replace the double-cast with a runtime type-narrow: call
ark.schema(jsonIr) into a local const (no cast), then implement and use a type
predicate/is-check (for example isArktypeSchemaLike) that verifies the returned
value is callable and has the expected shape (e.g., a function and the
"expression" property of type string or other required members), throw a clear
error if the check fails, and only then return the value typed as
ArktypeSchemaLike; reference rehydrateSchema and ark.schema when locating code
to change.

In `@packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts`:
- Around line 75-79: The test currently silences type + lint rules by using "as
any" and a "biome-ignore" comment; replace that with a TypeScript compile-time
suppression using `@ts-expect-error` plus a short reason above the offending call
to arktypeJsonColumn so the test still asserts the runtime guard without using
any/biome ignores. Locate the failing test in arktype-json-codec-class.test.ts
where arktypeJsonColumn(notASchema as any) is called and remove the "as any"
cast and the biome-ignore, adding a single-line "@ts-expect-error TS-EXPLAIN:
deliberate malformed input to exercise call-site guard" immediately above the
call.

In
`@packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts`:
- Around line 140-142: Replace the deprecated matcher usage: locate the
expectTypeOf assertion that references ColumnSpec<ArktypeJsonCodecClass<{ name:
string; price: number }>, ArktypeJsonTypeParams> (the expectTypeOf(col) line)
and change the matcher from toMatchTypeOf<...>() to toExtend<...>() so the
subtype-style compatibility check uses the approved Vitest matcher for
.test-d.ts files.

In `@packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts`:
- Around line 245-258: The codec must reject invalid Date instances and
non-strings: in encode and encodeJson (functions encode(value: Date, _ctx:
CodecCallContext) and encodeJson(value: Date)) check that value is a Date
(instanceof Date) and that
Number.isFinite(value.getTime())/!Number.isNaN(value.getTime()) before calling
toISOString(), and throw a TypeError if not; in decode and decodeJson
(decode(wire: string, _ctx: CodecCallContext) and decodeJson(json: JsonValue))
ensure the input is a string, construct the Date, then validate the produced
Date with Number.isFinite(date.getTime())/!Number.isNaN(...) and throw a
TypeError for invalid dates instead of returning them.

---

Nitpick comments:
In `@packages/3-targets/3-targets/postgres/test/codecs.test.ts`:
- Around line 75-82: The helper codecForScalar currently calls
descriptor.factory(undefined as never) which bypasses the public params contract
for parameterized descriptors; change codecForScalar to supply real params for
parameterized descriptors (e.g. via a small paramsByScalar map or conditional
helpers) and call descriptor.factory(params) for those scalars, falling back to
descriptor.factory() or descriptor.factory(undefined) only for true
non-parameterized descriptors so that descriptorByScalar/descriptor.factory and
SYNTH_CTX are exercised via the intended public API shape.

In `@packages/3-targets/6-adapters/postgres/src/core/adapter.ts`:
- Around line 44-60: The code silently calls factory(undefined) for each
descriptor from postgresCodecRegistry when constructing codecRegistry, which
assumes every descriptor is paramless; add a fail-fast check or helper next to
postgresCodecRegistry to enforce/verify that a descriptor is materializable
without params before calling factory(undefined). Concretely, introduce a small
predicate/helper (e.g., isParamlessDescriptor) or add an assertion in the
codecRegistry initializer that inspects the descriptor shape and throws a clear
error if params are required, and then only call (descriptor.factory)(undefined)
(or use the helper) to produce the codec instance; reference codecRegistry,
postgresCodecRegistry, CodecInstanceContext and the current factory(undefined)
usage when making the change.

In `@packages/3-targets/6-adapters/sqlite/src/core/adapter.ts`:
- Around line 55-70: The current codecRegistry eagerly materializes every
descriptor by calling descriptor.factory(undefined), which mis-instantiates
parameterized descriptors from sqliteCodecRegistry; change this to preserve
descriptor-based entries and only instantiate codecs when they are truly
parameterless: in the codecRegistry initialization (and related logic around
codecRegistry, sqliteCodecRegistry, CodecInstanceContext and factory), avoid
calling factory(undefined) for all descriptors—instead detect parameterized
descriptors (e.g., via a param-type flag or factory arity) and either keep the
original descriptor in the registry or only call factory() for descriptors known
to accept no params; ensure the fallback registry only materializes codecs whose
params are void so parameterized codecs remain descriptor-based.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yml

Review profile: CHILL

Plan: Pro

Run ID: 395e4d68-7371-4142-b775-7022bfe445bb

📥 Commits

Reviewing files that changed from the base of the PR and between 2d4eb3b and 583a8e9.

📒 Files selected for processing (46)

• packages/2-sql/4-lanes/relational-core/package.json
• packages/2-sql/4-lanes/relational-core/src/ast/sql-codecs-class.ts
• packages/2-sql/4-lanes/relational-core/src/codec-descriptor-registry.ts
• packages/2-sql/4-lanes/relational-core/src/exports/codec-descriptor-registry.ts
• packages/2-sql/4-lanes/relational-core/test/ast/sql-codecs-class.test.ts
• packages/2-sql/4-lanes/relational-core/test/ast/sql-codecs-class.types.test-d.ts
• packages/2-sql/4-lanes/relational-core/test/ast/sql-codecs.test.ts
• packages/2-sql/4-lanes/relational-core/test/typed-codec-flow.test-d.ts
• packages/2-sql/4-lanes/relational-core/tsdown.config.ts
• packages/2-sql/5-runtime/src/sql-context.ts
• packages/3-extensions/arktype-json/src/core/arktype-json-codec-class.ts
• packages/3-extensions/arktype-json/src/core/pack-meta.ts
• packages/3-extensions/arktype-json/src/exports/codecs.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec-class.test.ts
• packages/3-extensions/arktype-json/test/arktype-json-codec-class.types.test-d.ts
• packages/3-extensions/arktype-json/test/extension-descriptors.test.ts
• packages/3-extensions/pgvector/src/core/codecs-class.ts
• packages/3-extensions/pgvector/src/core/descriptor-meta.ts
• packages/3-extensions/pgvector/src/core/registry.ts
• packages/3-extensions/pgvector/src/exports/runtime.ts
• packages/3-extensions/pgvector/test/codec-render-output-type.test.ts
• packages/3-extensions/pgvector/test/codecs-class.types.test-d.ts
• packages/3-extensions/pgvector/test/codecs.test.ts
• packages/3-extensions/pgvector/test/typed-descriptor-flow.test-d.ts
• packages/3-targets/3-targets/postgres/src/core/codecs-class.ts
• packages/3-targets/3-targets/postgres/src/core/registry.ts
• packages/3-targets/3-targets/postgres/src/exports/codec-types.ts
• packages/3-targets/3-targets/postgres/src/exports/codecs.ts
• packages/3-targets/3-targets/postgres/test/codec-render-output-type.test.ts
• packages/3-targets/3-targets/postgres/test/codecs-class.test.ts
• packages/3-targets/3-targets/postgres/test/codecs-class.types.test-d.ts
• packages/3-targets/3-targets/postgres/test/codecs.test.ts
• packages/3-targets/3-targets/postgres/test/typed-descriptor-flow.test-d.ts
• packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts
• packages/3-targets/3-targets/sqlite/src/core/registry.ts
• packages/3-targets/3-targets/sqlite/src/exports/codec-types.ts
• packages/3-targets/3-targets/sqlite/src/exports/codecs.ts
• packages/3-targets/3-targets/sqlite/test/codecs-class.types.test-d.ts
• packages/3-targets/3-targets/sqlite/test/typed-descriptor-flow.test-d.ts
• packages/3-targets/6-adapters/postgres/src/core/adapter.ts
• packages/3-targets/6-adapters/postgres/src/core/codec-lookup.ts
• packages/3-targets/6-adapters/postgres/src/core/descriptor-meta.ts
• packages/3-targets/6-adapters/postgres/src/exports/runtime.ts
• packages/3-targets/6-adapters/sqlite/src/core/adapter.ts
• packages/3-targets/6-adapters/sqlite/src/core/runtime-adapter.ts
• packages/3-targets/6-adapters/sqlite/test/codecs.test.ts

✅ Files skipped from review due to trivial changes (9)

• packages/2-sql/4-lanes/relational-core/package.json
• packages/2-sql/4-lanes/relational-core/src/exports/codec-descriptor-registry.ts
• packages/3-targets/3-targets/postgres/src/core/registry.ts
• packages/3-extensions/pgvector/src/core/registry.ts
• packages/3-targets/3-targets/sqlite/src/core/registry.ts
• packages/2-sql/4-lanes/relational-core/tsdown.config.ts
• packages/3-extensions/arktype-json/src/exports/codecs.ts
• packages/3-extensions/arktype-json/src/core/pack-meta.ts
• packages/3-targets/3-targets/sqlite/src/exports/codecs.ts

🚧 Files skipped from review as they are similar to previous changes (4)

• packages/3-targets/3-targets/postgres/src/exports/codecs.ts
• packages/3-targets/3-targets/postgres/test/codecs-class.types.test-d.ts
• packages/2-sql/5-runtime/src/sql-context.ts
• packages/3-targets/3-targets/postgres/src/core/codecs-class.ts

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Fail fast on duplicate codecIds.

byId.set() silently overwrites the first descriptor, but byTargetType still retains both entries. That leaves the registry internally inconsistent: descriptorFor(id) returns the last descriptor while target-type iteration still sees every duplicate. Since this builder merges contributions from multiple packages, duplicate ids should throw during construction.

🐛 Minimal guard

   for (const descriptor of allDescriptors) {
     const widened = descriptor as unknown as AnyDescriptor;
+    if (byId.has(descriptor.codecId)) {
+      throw new Error(`Duplicate codec descriptor id: ${descriptor.codecId}`);
+    }
     byId.set(descriptor.codecId, widened);

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	for (const descriptor of allDescriptors) {
	const widened = descriptor as unknown as AnyDescriptor;
	byId.set(descriptor.codecId, widened);
	for (const targetType of descriptor.targetTypes) {
	const list = byTargetType.get(targetType);
	if (list) {
	list.push(widened);
	} else {
	byTargetType.set(targetType, [widened]);
	for (const descriptor of allDescriptors) {
	const widened = descriptor as unknown as AnyDescriptor;
	if (byId.has(descriptor.codecId)) {
	throw new Error(`Duplicate codec descriptor id: ${descriptor.codecId}`);
	}
	byId.set(descriptor.codecId, widened);
	for (const targetType of descriptor.targetTypes) {
	const list = byTargetType.get(targetType);
	if (list) {
	list.push(widened);
	} else {
	byTargetType.set(targetType, [widened]);
	}
	}
	}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/2-sql/4-lanes/relational-core/src/codec-descriptor-registry.ts`
around lines 31 - 39, The registry currently overwrites duplicate codecId
entries causing inconsistent state; before calling byId.set(descriptor.codecId,
widened) in the loop over allDescriptors (where widened is cast to
AnyDescriptor), check if byId.has(descriptor.codecId) and throw a clear error
(including the conflicting codecId and descriptor identity) to fail-fast on
duplicates; only proceed to add to byTargetType when the codecId is not already
present (so byId and byTargetType remain consistent and descriptorFor(id) will
match target-type lists).

[coderabbitai]

⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Carry length into the codec and validate every ingress path.

factory() currently discards params.length, so contractCodecs.forColumn(table, column) still produces a codec that behaves the same for vector(3) and vector(1536). Combined with decodeJson() blindly casting JsonValue to number[], wrong-dimension vectors and malformed JSON can slip through until much later instead of failing at the codec boundary. Thread the dimension into PgVectorCodec and reuse one validator from encode, decode, and decodeJson.

Suggested direction

 export class PgVectorCodec extends CodecImpl<
   typeof VECTOR_CODEC_ID,
   readonly ['equality'],
   string,
   number[]
 > {
+  constructor(
+    descriptor: PgVectorDescriptor,
+    private readonly length: number,
+  ) {
+    super(descriptor);
+  }
+
+  private assertVector(value: JsonValue | number[]): asserts value is number[] {
+    if (!Array.isArray(value)) {
+      throw new Error('Vector value must be an array of numbers');
+    }
+    if (!value.every((v) => typeof v === 'number')) {
+      throw new Error('Vector value must contain only numbers');
+    }
+    if (value.length !== this.length) {
+      throw new Error(`Vector length mismatch: expected ${this.length}, got ${value.length}`);
+    }
+  }
+
   async encode(value: number[], _ctx: CodecCallContext): Promise<string> {
-    if (!Array.isArray(value)) {
-      throw new Error('Vector value must be an array of numbers');
-    }
-    if (!value.every((v) => typeof v === 'number')) {
-      throw new Error('Vector value must contain only numbers');
-    }
+    this.assertVector(value);
     return `[${value.join(',')}]`;
   }

   async decode(wire: string, _ctx: CodecCallContext): Promise<number[]> {
     if (typeof wire !== 'string') {
       throw new Error('Vector wire value must be a string');
@@
-    return content.split(',').map((v) => {
+    const value = content.split(',').map((v) => {
       const num = Number.parseFloat(v.trim());
       if (Number.isNaN(num)) {
         throw new Error(`Invalid vector value: "${v}" is not a number`);
       }
       return num;
     });
+    this.assertVector(value);
+    return value;
   }
@@
   decodeJson(json: JsonValue): number[] {
-    return json as number[];
+    this.assertVector(json);
+    return json;
   }
 }
@@
   override factory(_params: VectorParams): (ctx: CodecInstanceContext) => PgVectorCodec {
-    return () => new PgVectorCodec(this);
+    return () => new PgVectorCodec(this, _params.length);
   }
 }

Also applies to: 130-131

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-extensions/pgvector/src/core/codecs-class.ts` around lines 82 -
118, The PgVectorCodec produced by factory() must retain params.length (the
declared dimension) and validate input across all ingress paths: modify
factory() to store the expected length on the PgVectorCodec instance, add a
single reused validator function (used by encode, decode, and decodeJson) that
checks the value is an array of numbers and that its length equals the stored
dimension, and update encodeJson/decodeJson/decode/encode to call that validator
and throw descriptive errors for wrong-dimension or non-numeric entries; ensure
contractCodecs.forColumn(table, column) returns a codec that enforces the
declared vector length rather than ignoring params.length.

[coderabbitai]

🛠️ Refactor suggestion | 🟠 Major | ⚡ Quick win

Keep src/exports/codec-types.ts as a pure re-export surface.

This entrypoint now computes codecDescriptorMap, Resolve, and CodecTypes inline. Please move that implementation under src/core/** and have this file only re-export the public type so the export surface stays declarative.

As per coding guidelines, packages/**/src/exports/{adapter,codec-types,types}.ts: re-export files in src/exports/ must re-export from core (../core/...) without adding additional logic.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/postgres/src/exports/codec-types.ts` around
lines 19 - 86, The file defines codecDescriptorMap, Resolve, and CodecTypes
inline which violates the export-only rule; move the codecDescriptorMap, Resolve
type helper, and the ExtractCodecTypes processing into a new or existing module
under src/core (e.g., export the computed type there) and then change
src/exports/codec-types.ts to only re-export the public type (export type {
CodecTypes } from '../core/...') so the exports file contains no computation or
logic and only exposes the type symbol CodecTypes.

[coderabbitai]

⚠️ Potential issue | 🟠 Major | 🏗️ Heavy lift

🧩 Analysis chain

🏁 Script executed:

# First, locate the file
find . -path "*sqlite/src/core/codecs-class.ts" -type f 2>/dev/null | head -5

Repository: prisma/prisma-next

Length of output: 125

---

🏁 Script executed:

# Check directory structure around the file
find . -path "*3-targets/sqlite/src*" -type f -name "*.ts" 2>/dev/null | head -20

Repository: prisma/prisma-next

Length of output: 1560

---

🏁 Script executed:

# Search for base64 utilities in the codebase
rg "base64|toBase64|fromBase64" --type ts -l | head -20

Repository: prisma/prisma-next

Length of output: 176

---

🏁 Script executed:

# Read the codecs-class.ts file
cat -n ./packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts | head -250

Repository: prisma/prisma-next

Length of output: 10865

---

🏁 Script executed:

# Check if Buffer is imported or used as a global
rg "Buffer|import.*Buffer" ./packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts -A 2 -B 2

Repository: prisma/prisma-next

Length of output: 639

---

🏁 Script executed:

# Search for base64 utilities in shared packages
find ./packages -path "*/shared*" -o -path "*/utils*" | xargs rg "base64" --type ts 2>/dev/null | head -30

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# Check what utilities exist in `@prisma-next/utils`
ls -la ./packages/framework/utils/src/ 2>/dev/null || ls -la ./packages/*/utils* 2>/dev/null | head -30

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# Check the full imports section of the file
head -60 ./packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts

Repository: prisma/prisma-next

Length of output: 2327

---

🏁 Script executed:

# Check if Buffer is imported anywhere
grep -n "import.*Buffer\|from.*Buffer" ./packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# See how Postgres handles base64 encoding in its codecs
cat ./packages/3-targets/3-targets/postgres/src/core/codecs-class.ts | grep -A 10 -B 5 "base64\|Buffer"

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# Check if there are any shared utilities for base64 encoding
find ./packages -name "*.ts" | xargs rg "base64.*encode|fromBase64|toBase64" --type ts -l | head -10

Repository: prisma/prisma-next

Length of output: 117

---

🏁 Script executed:

# Check how postgres handles blob/bytea codecs
find ./packages/3-targets/3-targets/postgres -name "*.ts" -type f | xargs grep -l "bytea\|blob\|base64" | head -5

Repository: prisma/prisma-next

Length of output: 211

---

🏁 Script executed:

# Read the postgres codecs-class.ts to see the blob/bytea implementation
cat ./packages/3-targets/3-targets/postgres/src/core/codecs-class.ts | grep -A 20 "bytea\|Bytea" | head -50

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# Search all files for base64 implementations
rg "toString\('base64'\)|from\(.*'base64'\)" --type ts -B 3 -A 3 | head -50

Repository: prisma/prisma-next

Length of output: 2104

---

🏁 Script executed:

# Check if Buffer needs to be imported or if it's used as global
rg "^import.*Buffer|^import.*from.*buffer" ./packages/3-targets/3-targets/sqlite --type ts

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# Check the file structure to understand the layer separation
ls -la ./packages/3-targets/3-targets/sqlite/src/

Repository: prisma/prisma-next

Length of output: 280

---

🏁 Script executed:

# Look for any exports files in the sqlite target
find ./packages/3-targets/3-targets/sqlite/src -name "exports" -o -name "*.exports.ts" | head -10

Repository: prisma/prisma-next

Length of output: 112

---

🏁 Script executed:

# Check the guidelines for how blob encoding should be handled in src/core
rg "src/core" ./packages/3-targets/3-targets/sqlite/src --type ts -l | head -5

Repository: prisma/prisma-next

Length of output: 254

---

🏁 Script executed:

# See if there's a runtime-specific exports path for sqlite codecs
find ./packages/3-targets/3-targets/sqlite -name "*.ts" | xargs grep -l "encodeJson.*Uint8Array" | head -10

Repository: prisma/prisma-next

Length of output: 125

---

🏁 Script executed:

# Check what's in the exports directory
ls -la ./packages/3-targets/3-targets/sqlite/src/exports/

Repository: prisma/prisma-next

Length of output: 1229

---

🏁 Script executed:

# Read the exports files to see how runtime-specific code is handled
cat ./packages/3-targets/3-targets/sqlite/src/exports/*.ts | head -100

Repository: prisma/prisma-next

Length of output: 3487

---

🏁 Script executed:

# Check the package.json to understand this package's context
cat ./packages/3-targets/3-targets/sqlite/package.json | head -50

Repository: prisma/prisma-next

Length of output: 1844

---

🏁 Script executed:

# Look at how other targets handle this - check PostgreSQL exports
ls -la ./packages/3-targets/3-targets/postgres/src/exports/ 2>/dev/null || echo "No exports dir in postgres"

Repository: prisma/prisma-next

Length of output: 1846

---

🏁 Script executed:

# Check the runtime.ts export file to understand the plane separation
cat ./packages/3-targets/3-targets/sqlite/src/exports/runtime.ts

Repository: prisma/prisma-next

Length of output: 187

---

🏁 Script executed:

# Check if there's any actual plane separation or if src/core imports from runtime
cat ./packages/3-targets/3-targets/sqlite/src/core/codecs.ts

Repository: prisma/prisma-next

Length of output: 430

---

🏁 Script executed:

# Look at how the codecs are registered or used
cat ./packages/3-targets/3-targets/sqlite/src/core/registry.ts 2>/dev/null || echo "No registry file"

Repository: prisma/prisma-next

Length of output: 746

---

🏁 Script executed:

# Check the actual directory structure to confirm Buffer usage location
ls -la ./packages/3-targets/3-targets/sqlite/src/core/ | grep codec

Repository: prisma/prisma-next

Length of output: 251

---

🏁 Script executed:

# Verify if codecs-class.ts is in core and check what imports it has
head -70 ./packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts | grep "^import\|^export"

Repository: prisma/prisma-next

Length of output: 199

---

🏁 Script executed:

# Check if there's a shared utility module for encoding/decoding
find ./packages -path "*/framework*" -o -path "*/utils*" -name "*.ts" | xargs grep -l "TextEncoder\|btoa\|atob" | head -10

Repository: prisma/prisma-next

Length of output: 631

---

🏁 Script executed:

# Check how Postgres handles bytea/binary data if it does
rg "Bytea|bytea" ./packages/3-targets/3-targets/postgres/src/core/ -A 5 -B 5 | head -80

Repository: prisma/prisma-next

Length of output: 2268

---

🏁 Script executed:

# Look for cross-platform encoding utilities in utils package
find ./packages -name "utils" -type d | xargs ls -la 2>/dev/null | head -20

Repository: prisma/prisma-next

Length of output: 1065

---

🏁 Script executed:

# Check what's in the framework utils for encoding
ls -la ./packages/framework/utils/src/ 2>/dev/null || find ./packages -path "*utils/src*" -type d -name "src" | head -3 | xargs ls -la

Repository: prisma/prisma-next

Length of output: 671

---

🏁 Script executed:

# Check what's exported from utils package
ls -la ./packages/1-framework/0-foundation/utils/src/exports/

Repository: prisma/prisma-next

Length of output: 605

---

🏁 Script executed:

# Look for any encoding utilities
rg "TextEncoder|TextDecoder|base64|Buffer" ./packages/1-framework/0-foundation/utils/src -l

Repository: prisma/prisma-next

Length of output: 44

---

🏁 Script executed:

# Check if there's a utilities file for encoding/base64
find ./packages -name "*.ts" | xargs grep -l "TextEncoder" | head -10

Repository: prisma/prisma-next

Length of output: 117

---

🏁 Script executed:

# Now check the dependency constraints - does src/core allow runtime imports?
cat ./packages/3-targets/3-targets/sqlite/package.json | grep -A 20 "dependencies"

Repository: prisma/prisma-next

Length of output: 925

---

🏁 Script executed:

# Verify the actual scope of the issue - check if this is the only use of Buffer in src/core
rg "Buffer" ./packages/3-targets/3-targets/sqlite/src/core/ --type ts

Repository: prisma/prisma-next

Length of output: 401

---

🏁 Script executed:

# Check if TextEncoder/TextDecoder are used elsewhere as an alternative
rg "TextEncoder|TextDecoder" ./packages -l --type ts | head -10

Repository: prisma/prisma-next

Length of output: 117

---

🏁 Script executed:

# Verify if this is truly in the shared plane (src/core) not runtime plane
cat ./packages/3-targets/3-targets/sqlite/src/exports/codecs.ts

Repository: prisma/prisma-next

Length of output: 578

---

🏁 Script executed:

# Final verification: confirm that Buffer is a Node-only global and there's no cross-platform fallback
node -e "console.log(typeof Buffer)"

Repository: prisma/prisma-next

Length of output: 71

---

🏁 Script executed:

# Check if any shared packages provide base64 encoding utilities
find ./packages/1-framework -name "*.ts" | xargs grep -l "base64\|toBase64\|fromBase64" | head -5

Repository: prisma/prisma-next

Length of output: 44

---

Avoid Node-only Buffer usage in src/core.

The base64 conversion in encodeJson() and decodeJson() methods makes this shared-plane codec depend on Node.js globals. This violates the guideline that src/core/** must remain runtime-neutral with no runtime-specific dependencies. The codec will fail in non-Node runtimes (browser, Deno, Bun, edge) unless a polyfill is injected. Use a cross-platform encoding utility (e.g., TextEncoder/TextDecoder from Web APIs, or a shared codec helper) instead.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/3-targets/3-targets/sqlite/src/core/codecs-class.ts` around lines
204 - 211, The encodeJson and decodeJson methods currently use Node-only Buffer;
replace that with a runtime-neutral base64 utility so src/core stays
platform-agnostic: implement or import cross-platform helpers (e.g.,
uint8ArrayToBase64 and base64ToUint8Array) that use Web APIs (atob/btoa or
TextEncoder/TextDecoder) and fall back to Buffer only when necessary, then
update encodeJson(value: Uint8Array) to return uint8ArrayToBase64(value) and
decodeJson(json: JsonValue) to validate string and return
base64ToUint8Array(json); keep the function names encodeJson and decodeJson
unchanged.