@prisma-next/sql-relational-core 0.5.0-dev.7 → 0.5.0-dev.70

package/src/exports/plan.ts

@@ -1 +1,2 @@
 export * from '../plan';
+export type { SqlExecutionPlan } from '../sql-execution-plan';

package/src/exports/types.ts

@@ -1 +1,2 @@
+export type { RuntimeScope, SqlOrmPlan } from '../runtime-scope';
 export * from '../types';

package/src/expression.ts

@@ -0,0 +1,134 @@
+import type { ParamSpec } from '@prisma-next/operations';
+import type { QueryOperationReturn } from '@prisma-next/sql-contract/types';
+import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
+import type { AnyExpression as AstExpression } from './ast/types';
+import { OperationExpr, ParamRef } from './ast/types';
+
+export type ScopeField = { codecId: string; nullable: boolean };
+
+/**
+ * A typed SQL expression. Identity is carried by the `returnType` descriptor (inherited from `QueryOperationReturn` and narrowed to `T`) — distinct `T` makes distinct Expression types structurally. `buildAst()` materialises the underlying AST node.
+ */
+export type Expression<T extends ScopeField> = QueryOperationReturn & {
+  readonly returnType: T;
+  buildAst(): AstExpression;
+};
+
+type CodecIdsWithTrait<
+  CT extends Record<string, { readonly input: unknown }>,
+  RequiredTraits extends readonly string[],
+> = {
+  [K in keyof CT & string]: CT[K] extends { readonly traits: infer T }
+    ? [RequiredTraits[number]] extends [T]
+      ? K
+      : never
+    : never;
+}[keyof CT & string];
+
+type NullSuffix<N> = N extends true ? null : never;
+
+/**
+ * An expression or literal value targeting a specific codec.
+ *
+ * Accepts any of:
+ * - An `Expression` whose codec matches exactly
+ * - A raw JS value of the codec's `input` type
+ * - `null` when `Nullable` is true
+ */
+export type CodecExpression<
+  CodecId extends string,
+  Nullable extends boolean,
+  CT extends Record<string, { readonly input: unknown }>,
+> =
+  | Expression<{ codecId: CodecId; nullable: Nullable }>
+  | (CodecId extends keyof CT ? CT[CodecId]['input'] : never)
+  | NullSuffix<Nullable>;
+
+/**
+ * An expression or literal value targeting any codec whose trait set contains all the required traits.
+ *
+ * Resolves the trait set to the union of matching codec identities via `CodecIdsWithTrait`, then reuses `CodecExpression` for the codec-id form.
+ */
+export type TraitExpression<
+  Traits extends readonly string[],
+  Nullable extends boolean,
+  CT extends Record<string, { readonly input: unknown }>,
+> = CodecExpression<CodecIdsWithTrait<CT, Traits>, Nullable, CT>;
+
+/**
+ * Resolve a raw value or an Expression into an AST expression node.
+ *
+ * When `value` is an Expression (duck-typed by its `buildAst` method), the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with `codecId` (if given) and optionally `refs: { table, column }` (if the caller knows the column-bound site).
+ *
+ * For parameterized codec ids (e.g. `pg/vector@1`), encode-side dispatch requires `refs` to select the per-instance codec — so operation implementations that compare a column to a user-supplied value should derive `refs` from the column-bound side and pass it down. Non-parameterized codec ids (e.g. `pg/int4@1`) tolerate refs-less ParamRefs; the validator pass enforces refs only for parameterized ids.
+ */
+export function toExpr(
+  value: unknown,
+  codecId?: string,
+  refs?: { table: string; column: string },
+): AstExpression {
+  if (isExpressionLike(value)) {
+    return value.buildAst();
+  }
+  if (codecId === undefined && refs === undefined) return ParamRef.of(value);
+  return ParamRef.of(value, {
+    ...(codecId !== undefined ? { codecId } : {}),
+    ...(refs !== undefined ? { refs } : {}),
+  });
+}
+
+/**
+ * Derive `(table, column)` refs from an expression-like value when it carries column-bound metadata. Returns `undefined` for non-column-bound expressions and for raw scalar values.
+ *
+ * Two sources are consulted, in order: 1. An optional `refs` slot on the `Expression` wrapper (the SQL builder's `ExpressionImpl` records `(table, column)` for top-level fields whose AST is `IdentifierRef` — the AST stays bare to preserve SQL rendering, the metadata lives on the wrapper). 2. The wrapped AST when it's already a `ColumnRef` (the namespaced field-proxy form, or operation impls passing column-bound exprs
+ * directly).
+ *
+ * Operation implementations call this on the column-bound side of a comparison and forward the refs to {@link toExpr} on the user-value side, so the resulting `ParamRef` carries the table+column required by encode-side `forColumn` dispatch.
+ */
+export function refsOf(value: unknown): { table: string; column: string } | undefined {
+  if (!isExpressionLike(value)) return undefined;
+  const wrapperRefs = (value as { refs?: { table: string; column: string } }).refs;
+  if (wrapperRefs) return { table: wrapperRefs.table, column: wrapperRefs.column };
+  const ast = value.buildAst();
+  if (ast.kind === 'column-ref') {
+    return { table: ast.table, column: ast.column };
+  }
+  return undefined;
+}
+
+function isExpressionLike(value: unknown): value is Expression<ScopeField> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'buildAst' in value &&
+    typeof (value as { buildAst: unknown }).buildAst === 'function'
+  );
+}
+
+export interface BuildOperationSpec<R extends ScopeField> {
+  readonly method: string;
+  /**
+   * The operation's arguments. The first element is the self argument (the value the operation is being applied to); the rest are the remaining user-supplied arguments.
+   */
+  readonly args: readonly [AstExpression, ...AstExpression[]];
+  readonly returns: R & ParamSpec;
+  readonly lowering: SqlLoweringSpec;
+}
+
+/**
+ * Construct an OperationExpr AST node and wrap it as a typed Expression. Operation implementations use this to turn their user-facing arguments into the AST node the compilation pipeline eventually lowers to SQL.
+ */
+export function buildOperation<R extends ScopeField>(spec: BuildOperationSpec<R>): Expression<R> {
+  const [self, ...rest] = spec.args;
+  const op = new OperationExpr({
+    method: spec.method,
+    self,
+    args: rest.length > 0 ? rest : undefined,
+    returns: spec.returns,
+    lowering: spec.lowering,
+  });
+  return {
+    returnType: spec.returns,
+    buildAst: () => op,
+  };
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './exports/ast';
 export * from './exports/errors';
+export * from './exports/expression';
 export * from './exports/plan';
 export * from './exports/query-lane-context';
 export * from './exports/types';

package/src/plan.ts

@@ -1,39 +1,20 @@
-import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';
-import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import type { QueryPlan } from '@prisma-next/framework-components/runtime';
 import type { AnyQueryAst } from './ast/types';
 
 /**
  * SQL query plan produced by lanes before lowering.
  *
- * Lanes build ASTs and metadata but do not perform SQL lowering.
- * The `sql` field is absent - lowering happens in the runtime executor.
+ * Lanes build ASTs and metadata but do not perform SQL lowering. The `sql`
+ * field is absent — `RuntimeCore` (the runtime base class in
+ * `@prisma-next/framework-components/runtime`) drives lowering via the
+ * SQL adapter and produces a `SqlExecutionPlan`.
  *
- * Structurally aligns with ExecutionPlan<Row, AnyQueryAst> (without sql field) to maintain
- * compatibility with ExecutionPlan/Plan-based utilities.
- * The generic parameter `_Row` is preserved for type extraction via ResultType.
+ * Extends the framework-level `QueryPlan<Row>` marker (`meta + _row`) and
+ * adds SQL-specific fields (`ast`, `params`). The phantom `_row` property
+ * (inherited from `QueryPlan`) is what `ResultType<P>` inspects to recover
+ * the row type.
  */
-export interface SqlQueryPlan<_Row = unknown>
-  extends Pick<ExecutionPlan<_Row, AnyQueryAst>, 'params' | 'meta'> {
+export interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> {
   readonly ast: AnyQueryAst;
-  // Phantom property to preserve generic parameter for type extraction
-  // This allows ResultType to extract _Row for SqlQueryPlan values.
-  readonly _Row?: _Row;
-}
-
-/**
- * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.
- * This is used when building WHERE expressions to ensure param descriptors have type information.
- */
-export function augmentDescriptorWithColumnMeta(
-  descriptors: ParamDescriptor[],
-  columnMeta: StorageColumn | undefined,
-): void {
-  const descriptor = descriptors[descriptors.length - 1];
-  if (descriptor && columnMeta) {
-    descriptors[descriptors.length - 1] = {
-      ...descriptor,
-      codecId: columnMeta.codecId,
-      nativeType: columnMeta.nativeType,
-    };
-  }
+  readonly params: readonly unknown[];
 }

package/src/query-lane-context.ts

@@ -1,55 +1,31 @@
 import type { Contract } from '@prisma-next/contract/types';
+import type { CodecDescriptor } from '@prisma-next/framework-components/codec';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { SqlOperationRegistry } from '@prisma-next/sql-operations';
-import type { CodecRegistry } from './ast/codec-types';
+import type { ContractCodecRegistry } from './ast/codec-types';
 
 /**
- * Registry of initialized type helpers from storage.types.
- * Each key is a type name from storage.types, and the value is:
- * - The result of the codec's init hook (if provided), or
- * - The full StorageTypeInstance metadata (codecId, nativeType, typeParams) if no init hook
+ * Codec-id-keyed accessor for descriptor metadata. The unified read API for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`) — non-branching for parameterized vs. non-parameterized codecs. Every codec ships natively as a `CodecDescriptor` through the unified `codecs:` contributor slot (see ADR 208).
  */
-export type TypeHelperRegistry = Record<string, unknown>;
-
-// =============================================================================
-// JSON Schema Validation Types
-// =============================================================================
-
-/**
- * A single validation error from JSON Schema validation.
- */
-export interface JsonSchemaValidationError {
-  readonly path: string;
-  readonly message: string;
-  readonly keyword: string;
+export interface CodecDescriptorRegistry {
+  /**
+   * Descriptors carry distinct param shapes per codec id; the registry is heterogeneous and the consumer narrows per codec.
+   */
+  descriptorFor(codecId: string): CodecDescriptor<unknown> | undefined;
+  /**
+   * All registered descriptors. Used by `validateCodecRegistryCompleteness` and other startup-time consumers that enumerate descriptors.
+   */
+  values(): IterableIterator<CodecDescriptor<unknown>>;
+  /**
+   * Descriptors indexed by `targetTypes[i]` (each scalar type the codec advertises). Multiple descriptors may map to the same scalar type; ordering reflects registration order.
+   */
+  byTargetType(targetType: string): readonly CodecDescriptor<unknown>[];
 }
 
 /**
- * Result of a JSON Schema validation.
- */
-export type JsonSchemaValidationResult =
-  | { readonly valid: true }
-  | { readonly valid: false; readonly errors: ReadonlyArray<JsonSchemaValidationError> };
-
-/**
- * A compiled JSON Schema validate function.
- * Returns a structured result indicating whether the value conforms to the schema.
+ * Registry of initialized type helpers from storage.types. Each key is a type name from storage.types, and the value is the resolved codec materialized once for that named instance via `descriptor.factory(typeParams)(ctx)` (or the raw `StorageTypeInstance` metadata for codec ids whose descriptor isn't registered).
  */
-export type JsonSchemaValidateFn = (value: unknown) => JsonSchemaValidationResult;
-
-/**
- * Registry of compiled JSON Schema validators for columns with typed JSON/JSONB.
- *
- * Built during context creation by scanning the contract for columns whose codec
- * descriptor provides an `init` hook that returns a `{ validate }` helper.
- * Keys are `"table.column"` (e.g., `"user.metadata"`).
- */
-export interface JsonSchemaValidatorRegistry {
-  /** Get the compiled validator for a column. Key format: "table.column". */
-  get(key: string): JsonSchemaValidateFn | undefined;
-  /** Number of registered validators. */
-  readonly size: number;
-}
+export type TypeHelperRegistry = Record<string, unknown>;
 
 export type MutationDefaultsOp = 'create' | 'update';
 
@@ -62,32 +38,36 @@ export type MutationDefaultsOptions = {
   readonly op: MutationDefaultsOp;
   readonly table: string;
   readonly values: Record<string, unknown>;
+  /**
+   * Per-ORM-operation cache for generators that declare `stability: 'query'`. The caller passes the same `Map` across every `applyMutationDefaults` invocation in one bulk operation; the framework keys by `generatorId` so the same value is reused across all rows and columns. Generators with `stability: 'row'` use a fresh per-call cache the framework manages internally; generators with `stability: 'field'` skip caching
+   * entirely. Omit to make every call independent (degrades `'query'` to per-call behavior).
+   */
+  readonly defaultValueCache?: Map<string, unknown>;
 };
 
 /**
  * Minimal context interface for SQL query lanes.
  *
- * Lanes only need contract, operations, and codecs to build typed ASTs and attach
- * operation builders. This interface explicitly excludes runtime concerns like
- * adapters, connection management, and transaction state.
+ * Lanes only need contract, operations, and codecs to build typed ASTs and attach operation builders. This interface explicitly excludes runtime concerns like adapters, connection management, and transaction state.
  */
 export interface ExecutionContext<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
   readonly contract: TContract;
-  readonly codecs: CodecRegistry;
-  readonly queryOperations: SqlOperationRegistry;
   /**
-   * Type helper registry for parameterized types.
-   * Schema builders expose these helpers via schema.types.
+   * Contract-bound codec registry built once at context-construction time by walking the contract's columns and resolving each through its descriptor's factory. The dispatch path (`encodeParam` / `decodeRow`) consults `forColumn(table, column)` for column-bound call sites; `forCodecId(codecId)` is the refs-less fallback, permitted only for non-parameterized codec ids (the builder-pipeline validator pass enforces refs on
+   * every parameterized `ParamRef`). Pre-populated with one canonical instance per non-parameterized descriptor so `forCodecId` covers refs-less codec ids that no contract column declares.
    */
-  readonly types: TypeHelperRegistry;
+  readonly contractCodecs: ContractCodecRegistry;
   /**
-   * Compiled JSON Schema validators for typed JSON/JSONB columns.
-   * Present only when the contract declares columns with JSON Schema typeParams.
+   * Codec-id-keyed descriptor map. Single source of truth for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`) — every codec, parameterized or not, resolves through this map without branching.
    */
-  readonly jsonSchemaValidators?: JsonSchemaValidatorRegistry;
+  readonly codecDescriptors: CodecDescriptorRegistry;
+  readonly queryOperations: SqlOperationRegistry;
+  /**
+   * Type helper registry for parameterized types. Schema builders expose these helpers via schema.types.
+   */
+  readonly types: TypeHelperRegistry;
   /**
-   * Applies execution-time mutation defaults for the given table.
-   * Returns the applied defaults (caller-provided values always win).
+   * Applies execution-time mutation defaults for the given table. Returns the applied defaults (caller-provided values always win).
    */
   applyMutationDefaults(options: MutationDefaultsOptions): ReadonlyArray<AppliedMutationDefault>;
 }

package/src/runtime-scope.ts

@@ -0,0 +1,20 @@
+import type { RuntimeExecutor } from '@prisma-next/framework-components/runtime';
+import type { SqlQueryPlan } from './plan';
+import type { SqlExecutionPlan } from './sql-execution-plan';
+
+/**
+ * The plan shape accepted by the SQL ORM client and SQL runtime: either a
+ * pre-lowering `SqlQueryPlan` (AST + meta) or a post-lowering
+ * `SqlExecutionPlan` (sql + params + meta).
+ */
+export type SqlOrmPlan = SqlExecutionPlan | SqlQueryPlan;
+
+/**
+ * The minimal SQL-runtime surface that the ORM client and SQL runtime both
+ * depend on: the `execute` method of `RuntimeExecutor<SqlOrmPlan>`.
+ *
+ * Owned by `sql-relational-core` (lanes layer) so both
+ * `@prisma-next/sql-runtime` and `@prisma-next/sql-orm-client` consume the
+ * same source of truth without a layering inversion.
+ */
+export type RuntimeScope = Pick<RuntimeExecutor<SqlOrmPlan>, 'execute'>;

package/src/sql-execution-plan.ts

@@ -0,0 +1,28 @@
+import type { ExecutionPlan } from '@prisma-next/framework-components/runtime';
+import type { AnyQueryAst } from './ast/types';
+
+/**
+ * SQL-domain execution plan: a query lowered to the wire-level shape that a
+ * SQL driver can run.
+ *
+ * The plan carries:
+ * - `sql` — the rendered SQL text
+ * - `params` — the bound parameter list
+ * - `ast` — optional pre-lowering AST, retained for telemetry / debugging
+ * - `meta` — family-agnostic plan metadata (target, lane, hashes, ...)
+ * - `_row` — phantom row type, propagated from the originating `SqlQueryPlan`
+ *
+ * Extends the framework-level `ExecutionPlan<Row>` marker so generic SPIs
+ * (`RuntimeExecutor<SqlExecutionPlan>`, `RuntimeMiddleware<SqlExecutionPlan>`)
+ * can be parameterized over it.
+ *
+ * Co-located with `SqlQueryPlan` (its pre-lowering counterpart) in the lanes
+ * layer because lane-level utilities (`RawTemplateFactory`, `RawFactory`,
+ * `SqlPlan`) compose against the executable shape and the lanes layer cannot
+ * depend on the runtime layer.
+ */
+export interface SqlExecutionPlan<Row = unknown> extends ExecutionPlan<Row> {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+  readonly ast?: AnyQueryAst;
+}

package/src/types.ts

@@ -1,9 +1,4 @@
-import type {
-  Contract,
-  ResultType as CoreResultType,
-  ExecutionPlan,
-  PlanRefs,
-} from '@prisma-next/contract/types';
+import type { Contract } from '@prisma-next/contract/types';
 import type { ParamSpec } from '@prisma-next/operations';
 import type {
   ExtractFieldOutputTypes,
@@ -11,9 +6,9 @@ import type {
   StorageColumn,
 } from '@prisma-next/sql-contract/types';
 import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
-import type { AnyQueryAst, ColumnRef, ParamRef } from './ast/types';
-import type { SqlQueryPlan } from './plan';
+import type { ColumnRef, ParamRef } from './ast/types';
 import type { ExecutionContext } from './query-lane-context';
+import type { SqlExecutionPlan } from './sql-execution-plan';
 
 export type Expr = ColumnRef | ParamRef;
 
@@ -179,10 +174,11 @@ export type HasIncludeManyCapabilities<TContract extends Contract<SqlStorage>> =
   : false;
 
 /**
- * SQL-specific Plan type that refines the ast field to use AnyQueryAst.
- * This is the type used by SQL query builders.
+ * Alias for the SQL-domain executable plan, exposed under the legacy
+ * `SqlPlan` name for compatibility with SQL builder/utility call sites.
+ * The canonical name is `SqlExecutionPlan` (`./sql-execution-plan`).
  */
-export type SqlPlan<Row = unknown> = ExecutionPlan<Row, AnyQueryAst>;
+export type SqlPlan<Row = unknown> = SqlExecutionPlan<Row>;
 
 /**
  * Helper types for extracting contract structure.
@@ -248,9 +244,7 @@ export type ColumnsOf<
   : never;
 
 export interface RawTemplateOptions {
-  readonly refs?: PlanRefs;
   readonly annotations?: Record<string, unknown>;
-  readonly projection?: ReadonlyArray<string>;
 }
 
 export interface RawFunctionOptions extends RawTemplateOptions {
@@ -260,10 +254,10 @@ export interface RawFunctionOptions extends RawTemplateOptions {
 export type RawTemplateFactory = (
   strings: TemplateStringsArray,
   ...values: readonly unknown[]
-) => ExecutionPlan;
+) => SqlExecutionPlan;
 
 export interface RawFactory extends RawTemplateFactory {
-  (text: string, options: RawFunctionOptions): ExecutionPlan;
+  (text: string, options: RawFunctionOptions): SqlExecutionPlan;
   with(options: RawTemplateOptions): RawTemplateFactory;
 }
 
@@ -287,10 +281,3 @@ export interface BuildOptions {
 export interface SqlBuilderOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
   readonly context: ExecutionContext<TContract>;
 }
-
-/**
- * SQL-specific ResultType that works with both Plan and SqlQueryPlan.
- * This extends the core ResultType to also handle SqlQueryPlan.
- * Example: `type Row = ResultType<typeof plan>`
- */
-export type ResultType<P> = P extends SqlQueryPlan<infer R> ? R : CoreResultType<P>;

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

@@ -1,144 +0,0 @@
-import { Type } from "arktype";
-import { JsonValue } from "@prisma-next/contract/types";
-import { Codec, CodecTrait, CodecTrait as CodecTrait$1 } from "@prisma-next/framework-components/codec";
-import { O } from "ts-toolbelt";
-
-//#region src/ast/codec-types.d.ts
-
-/**
- * Descriptor for parameterized codecs that require type parameter validation.
- * Shared between adapter (compile-time) and runtime layers to avoid duplication.
- *
- * @template TParams - The shape of the type parameters (e.g., `{ length: number }`)
- * @template THelper - The type returned by the optional `init` hook
- */
-interface CodecParamsDescriptor<TParams = Record<string, unknown>, THelper = unknown> {
-  /** The codec ID this descriptor applies to (e.g., 'pg/vector@1') */
-  readonly codecId: string;
-  /**
-   * Arktype schema for validating typeParams.
-   * Used to validate both storage.types entries and inline column typeParams.
-   */
-  readonly paramsSchema: Type<TParams>;
-  /**
-   * Optional init hook called during runtime context creation.
-   * Receives validated params and returns a helper object to be stored in context.types.
-   * If not provided, the validated params are stored directly.
-   */
-  readonly init?: (params: TParams) => THelper;
-}
-/**
- * Codec metadata for database-specific type information.
- * Used for schema introspection and verification.
- */
-interface CodecMeta {
-  readonly db?: {
-    readonly sql?: {
-      readonly postgres?: {
-        readonly nativeType: string;
-      };
-    };
-  };
-}
-/**
- * SQL codec interface — extends the framework base with SQL-specific fields.
- *
- * Codecs are pure, synchronous functions with no side effects or IO.
- * They provide deterministic conversion between database wire types and JS values,
- * and between JS values and contract JSON.
- */
-interface Codec$1<Id$1 extends string = string, TTraits$1 extends readonly CodecTrait[] = readonly CodecTrait[], TWire = unknown, TJs = unknown, TParams = Record<string, unknown>, THelper = unknown> extends Codec<Id$1, TTraits$1, TWire, TJs> {
-  readonly meta?: CodecMeta;
-  readonly paramsSchema?: Type<TParams>;
-  readonly init?: (params: TParams) => THelper;
-}
-/**
- * Registry interface for codecs organized by ID and by contract scalar type.
- *
- * The registry allows looking up codecs by their namespaced ID or by the
- * contract scalar types they handle. Multiple codecs may handle the same
- * scalar type; ordering in byScalar reflects preference (adapter first,
- * then packs, then app overrides).
- */
-interface CodecRegistry {
-  get(id: string): Codec$1<string> | undefined;
-  has(id: string): boolean;
-  getByScalar(scalar: string): readonly Codec$1<string>[];
-  getDefaultCodec(scalar: string): Codec$1<string> | undefined;
-  register(codec: Codec$1<string>): void;
-  /** Returns true if the codec with this ID has the given trait. */
-  hasTrait(codecId: string, trait: CodecTrait): boolean;
-  /** Returns all traits for a codec, or an empty array if not found. */
-  traitsOf(codecId: string): readonly CodecTrait[];
-  [Symbol.iterator](): Iterator<Codec$1<string>>;
-  values(): IterableIterator<Codec$1<string>>;
-}
-/**
- * Codec factory - creates a codec with typeId and encode/decode functions.
- * Provides identity defaults for encodeJson/decodeJson when not supplied.
- */
-declare function codec<Id$1 extends string, const TTraits$1 extends readonly CodecTrait[], TWire, TJs, TParams = Record<string, unknown>, THelper = unknown>(config: {
-  typeId: Id$1;
-  targetTypes: readonly string[];
-  encode: (value: TJs) => TWire;
-  decode: (wire: TWire) => TJs;
-  encodeJson?: (value: TJs) => JsonValue;
-  decodeJson?: (json: JsonValue) => TJs;
-  meta?: CodecMeta;
-  paramsSchema?: Type<TParams>;
-  init?: (params: TParams) => THelper;
-  traits?: TTraits$1;
-  renderOutputType?: (typeParams: Record<string, unknown>) => string | undefined;
-}): Codec$1<Id$1, TTraits$1, TWire, TJs, TParams, THelper>;
-/**
- * Type helpers to extract codec types.
- */
-type CodecId<T> = T extends Codec$1<infer Id> ? Id : T extends {
-  readonly id: infer Id;
-} ? Id : never;
-type CodecInput<T> = T extends Codec$1<string, readonly CodecTrait[], unknown, infer JsT> ? JsT : never;
-type CodecOutput<T> = T extends Codec$1<string, readonly CodecTrait[], unknown, infer JsT> ? JsT : never;
-type CodecTraits<T> = T extends Codec$1<string, infer TTraits> ? TTraits[number] & CodecTrait : never;
-/**
- * Type helper to extract codec types from builder instance.
- */
-type ExtractCodecTypes<ScalarNames extends { readonly [K in keyof ScalarNames]: Codec$1<string> } = Record<never, never>> = { readonly [K in keyof ScalarNames as ScalarNames[K] extends Codec$1<infer Id> ? Id : never]: {
-  readonly input: CodecInput<ScalarNames[K]>;
-  readonly output: CodecOutput<ScalarNames[K]>;
-  readonly traits: CodecTraits<ScalarNames[K]>;
-} };
-/**
- * Type helper to extract data type IDs from builder instance.
- * Uses ExtractCodecTypes which preserves literal types as keys.
- * Since ExtractCodecTypes<Record<K, ScalarNames[K]>> has exactly one key (the Id),
- * we extract it by creating a mapped type that uses the Id as both key and value,
- * then extract the value type. This preserves literal types.
- */
-type ExtractDataTypes<ScalarNames extends { readonly [K in keyof ScalarNames]: Codec$1<string> }> = { readonly [K in keyof ScalarNames]: { readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>] };
-/**
- * Builder interface for declaring codecs.
- */
-interface CodecDefBuilder<ScalarNames extends { readonly [K in keyof ScalarNames]: Codec$1<string> } = Record<never, never>> {
-  readonly CodecTypes: ExtractCodecTypes<ScalarNames>;
-  add<ScalarName extends string, CodecImpl extends Codec$1<string>>(scalarName: ScalarName, codecImpl: CodecImpl): CodecDefBuilder<O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>>;
-  readonly codecDefinitions: { readonly [K in keyof ScalarNames]: {
-    readonly typeId: ScalarNames[K] extends Codec$1<infer Id extends string> ? Id : never;
-    readonly scalar: K;
-    readonly codec: ScalarNames[K];
-    readonly input: CodecInput<ScalarNames[K]>;
-    readonly output: CodecOutput<ScalarNames[K]>;
-    readonly jsType: CodecOutput<ScalarNames[K]>;
-  } };
-  readonly dataTypes: { readonly [K in keyof ScalarNames]: { readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>] };
-}
-/**
- * Create a new codec registry.
- */
-declare function createCodecRegistry(): CodecRegistry;
-/**
- * Create a new codec definition builder.
- */
-declare function defineCodecs(): CodecDefBuilder<Record<never, never>>;
-//#endregion
-export { CodecMeta as a, CodecRegistry as c, ExtractCodecTypes as d, ExtractDataTypes as f, defineCodecs as h, CodecInput as i, CodecTrait$1 as l, createCodecRegistry as m, CodecDefBuilder as n, CodecOutput as o, codec as p, CodecId as r, CodecParamsDescriptor as s, Codec$1 as t, CodecTraits as u };
-//# sourceMappingURL=codec-types-DcEITed4.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-DcEITed4.d.mts","names":[],"sources":["../src/ast/codec-types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/errors-ChY_dHam.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-ChY_dHam.d.mts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;;iBAEgB,WAAA,4BAEJ,+EAGT;iBAkBa,eAAA,4BAEJ,+EAGT"}

package/dist/exports/plan.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.mjs","names":[],"sources":["../../src/plan.ts"],"sourcesContent":["import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { AnyQueryAst } from './ast/types';\n\n/**\n * SQL query plan produced by lanes before lowering.\n *\n * Lanes build ASTs and metadata but do not perform SQL lowering.\n * The `sql` field is absent - lowering happens in the runtime executor.\n *\n * Structurally aligns with ExecutionPlan<Row, AnyQueryAst> (without sql field) to maintain\n * compatibility with ExecutionPlan/Plan-based utilities.\n * The generic parameter `_Row` is preserved for type extraction via ResultType.\n */\nexport interface SqlQueryPlan<_Row = unknown>\n  extends Pick<ExecutionPlan<_Row, AnyQueryAst>, 'params' | 'meta'> {\n  readonly ast: AnyQueryAst;\n  // Phantom property to preserve generic parameter for type extraction\n  // This allows ResultType to extract _Row for SqlQueryPlan values.\n  readonly _Row?: _Row;\n}\n\n/**\n * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.\n * This is used when building WHERE expressions to ensure param descriptors have type information.\n */\nexport function augmentDescriptorWithColumnMeta(\n  descriptors: ParamDescriptor[],\n  columnMeta: StorageColumn | undefined,\n): void {\n  const descriptor = descriptors[descriptors.length - 1];\n  if (descriptor && columnMeta) {\n    descriptors[descriptors.length - 1] = {\n      ...descriptor,\n      codecId: columnMeta.codecId,\n      nativeType: columnMeta.nativeType,\n    };\n  }\n}\n"],"mappings":";;;;;AA0BA,SAAgB,gCACd,aACA,YACM;CACN,MAAM,aAAa,YAAY,YAAY,SAAS;AACpD,KAAI,cAAc,WAChB,aAAY,YAAY,SAAS,KAAK;EACpC,GAAG;EACH,SAAS,WAAW;EACpB,YAAY,WAAW;EACxB"}

package/dist/plan-Cs65hb-E.d.mts

@@ -1,28 +0,0 @@
-import { d as AnyQueryAst } from "./types-C3Hg-CVz.mjs";
-import { ExecutionPlan, ParamDescriptor } from "@prisma-next/contract/types";
-import { StorageColumn } from "@prisma-next/sql-contract/types";
-
-//#region src/plan.d.ts
-
-/**
- * SQL query plan produced by lanes before lowering.
- *
- * Lanes build ASTs and metadata but do not perform SQL lowering.
- * The `sql` field is absent - lowering happens in the runtime executor.
- *
- * Structurally aligns with ExecutionPlan<Row, AnyQueryAst> (without sql field) to maintain
- * compatibility with ExecutionPlan/Plan-based utilities.
- * The generic parameter `_Row` is preserved for type extraction via ResultType.
- */
-interface SqlQueryPlan<_Row = unknown> extends Pick<ExecutionPlan<_Row, AnyQueryAst>, 'params' | 'meta'> {
-  readonly ast: AnyQueryAst;
-  readonly _Row?: _Row;
-}
-/**
- * Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.
- * This is used when building WHERE expressions to ensure param descriptors have type information.
- */
-declare function augmentDescriptorWithColumnMeta(descriptors: ParamDescriptor[], columnMeta: StorageColumn | undefined): void;
-//#endregion
-export { augmentDescriptorWithColumnMeta as n, SqlQueryPlan as t };
-//# sourceMappingURL=plan-Cs65hb-E.d.mts.map

package/dist/plan-Cs65hb-E.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-Cs65hb-E.d.mts","names":[],"sources":["../src/plan.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAcA;;;;;;;;AAYgB,UAZC,YAYD,CAAA,OAAA,OAA+B,CAAA,SAXrC,IAYK,CAZA,aAaD,CAbe,IAaf,EAbqB,WAaR,CAAA,EAAA,QAAA,GAAA,MAAA,CAAA,CAAA;gBAZX;kBAGE;;;;;;iBAOF,+BAAA,cACD,+BACD"}