@prisma-next/sql-relational-core 0.5.0-dev.8 → 0.5.0-dev.80

package/dist/exports/plan.mjs

@@ -1,17 +1,34 @@
 //#region src/plan.ts
 /**
-* 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.
+* Wraps an `AnyQueryAst` (typically a `RawSqlExpr` constructed package-internally
+* by an extension's migration factory) in a fully-populated `SqlQueryPlan`
+* whose `meta` is sourced from the supplied contract.
+*
+* Centralising the envelope here means consumers (cipherstash migration
+* factories today; future raw-sql callers) cannot drift on `storageHash` /
+* `target` / `targetFamily`, which would otherwise surface as a subtle
+* `assertContractMatches` failure inside `dataTransform`. `params` defaults
+* to `[]` because parameters embedded in the AST as `ParamRef`s are resolved
+* at lowering time (`encodeParams` walks `plan.ast.collectParamRefs()`),
+* not at plan-construction time.
+*
+* The default `laneId` of `'raw'` reflects raw-SQL plans' standard lane tag;
+* callers (e.g. a future `sql-raw-factory`) may override to differentiate
+* the plan's provenance.
 */
-function augmentDescriptorWithColumnMeta(descriptors, columnMeta) {
-	const descriptor = descriptors[descriptors.length - 1];
-	if (descriptor && columnMeta) descriptors[descriptors.length - 1] = {
-		...descriptor,
-		codecId: columnMeta.codecId,
-		nativeType: columnMeta.nativeType
+function planFromAst(ast, contract, laneId = "raw") {
+	return {
+		ast,
+		params: [],
+		meta: {
+			target: contract.target,
+			targetFamily: contract.targetFamily,
+			storageHash: contract.storage.storageHash,
+			lane: laneId
+		}
 	};
 }
-
 //#endregion
-export { augmentDescriptorWithColumnMeta };
+export { planFromAst };
+
 //# sourceMappingURL=plan.mjs.map

package/dist/exports/plan.mjs.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"plan.mjs","names":[],"sources":["../../src/plan.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { QueryPlan } from '@prisma-next/framework-components/runtime';\nimport type { SqlStorage } 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. The `sql`\n * field is absent — `RuntimeCore` (the runtime base class in\n * `@prisma-next/framework-components/runtime`) drives lowering via the\n * SQL adapter and produces a `SqlExecutionPlan`.\n *\n * Extends the framework-level `QueryPlan<Row>` marker (`meta + _row`) and\n * adds SQL-specific fields (`ast`, `params`). The phantom `_row` property\n * (inherited from `QueryPlan`) is what `ResultType<P>` inspects to recover\n * the row type.\n */\nexport interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> {\n  readonly ast: AnyQueryAst;\n  readonly params: readonly unknown[];\n}\n\n/**\n * Wraps an `AnyQueryAst` (typically a `RawSqlExpr` constructed package-internally\n * by an extension's migration factory) in a fully-populated `SqlQueryPlan`\n * whose `meta` is sourced from the supplied contract.\n *\n * Centralising the envelope here means consumers (cipherstash migration\n * factories today; future raw-sql callers) cannot drift on `storageHash` /\n * `target` / `targetFamily`, which would otherwise surface as a subtle\n * `assertContractMatches` failure inside `dataTransform`. `params` defaults\n * to `[]` because parameters embedded in the AST as `ParamRef`s are resolved\n * at lowering time (`encodeParams` walks `plan.ast.collectParamRefs()`),\n * not at plan-construction time.\n *\n * The default `laneId` of `'raw'` reflects raw-SQL plans' standard lane tag;\n * callers (e.g. a future `sql-raw-factory`) may override to differentiate\n * the plan's provenance.\n */\nexport function planFromAst<Row = unknown>(\n  ast: AnyQueryAst,\n  contract: Contract<SqlStorage>,\n  laneId = 'raw',\n): SqlQueryPlan<Row> {\n  return {\n    ast,\n    params: [],\n    meta: {\n      target: contract.target,\n      targetFamily: contract.targetFamily,\n      storageHash: contract.storage.storageHash,\n      lane: laneId,\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwCA,SAAgB,YACd,KACA,UACA,SAAS,OACU;CACnB,OAAO;EACL;EACA,QAAQ,EAAE;EACV,MAAM;GACJ,QAAQ,SAAS;GACjB,cAAc,SAAS;GACvB,aAAa,SAAS,QAAQ;GAC9B,MAAM;GACP;EACF"}

package/dist/exports/query-lane-context.d.mts

@@ -1,3 +1,2 @@
-import "../codec-types-B2Xdq0Wr.mjs";
-import { a as JsonSchemaValidationResult, c as MutationDefaultsOptions, i as JsonSchemaValidationError, l as TypeHelperRegistry, n as ExecutionContext, o as JsonSchemaValidatorRegistry, r as JsonSchemaValidateFn, s as MutationDefaultsOp, t as AppliedMutationDefault } from "../query-lane-context-D2H78Mg0.mjs";
-export { AppliedMutationDefault, ExecutionContext, JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult, JsonSchemaValidatorRegistry, MutationDefaultsOp, MutationDefaultsOptions, TypeHelperRegistry };
+import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "../query-lane-context-C2tLZGp4.mjs";
+export { AppliedMutationDefault, CodecDescriptorRegistry, ExecutionContext, MutationDefaultsOp, MutationDefaultsOptions, TypeHelperRegistry };

package/dist/exports/query-lane-context.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/dist/exports/types.d.mts

@@ -1,4 +1,3 @@
-import "../codec-types-B2Xdq0Wr.mjs";
-import "../query-lane-context-D2H78Mg0.mjs";
-import { C as TableDef, E as TablesOf, S as SqlPlan, T as TableMetadata, _ as RawTemplateFactory, a as ComputeColumnJsType, b as RuntimeError, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnsOf, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as Expr, p as OperationTypes, r as CodecTypes, s as HasIncludeManyCapabilities, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TableKey, x as SqlBuilderOptions, y as ResultType } from "../types-D3vVZzRZ.mjs";
-export { BuildOptions, BuildParamsMap, CodecTypes, ColumnsOf, ComputeColumnJsType, Expr, HasIncludeManyCapabilities, META, Meta, ModelDef, ModelMetadata, OperationTypeSignature, OperationTypes, OperationsForTypeId, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, RuntimeError, SqlBuilderOptions, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf };
+import { C as TableKey, S as TableDef, T as TablesOf, _ as RawTemplateFactory, a as ComputeColumnJsType, b as SqlBuilderOptions, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnsOf, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as Expr, p as OperationTypes, r as CodecTypes, s as HasIncludeManyCapabilities, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TableMetadata, x as SqlPlan, y as RuntimeError } from "../types-D6Pk1DTr.mjs";
+import { n as SqlOrmPlan, t as RuntimeScope } from "../types-CL18G37a.mjs";
+export { BuildOptions, BuildParamsMap, CodecTypes, ColumnsOf, ComputeColumnJsType, Expr, HasIncludeManyCapabilities, META, Meta, ModelDef, ModelMetadata, OperationTypeSignature, OperationTypes, OperationsForTypeId, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, RuntimeError, RuntimeScope, SqlBuilderOptions, SqlOrmPlan, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf };

package/dist/exports/types.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/dist/index.d.mts

@@ -1,11 +1,12 @@
-import { a as CodecMeta, c as CodecTrait, d as ExtractDataTypes, f as codec, i as CodecInput, l as CodecTraits, m as defineCodecs, n as CodecDefBuilder, o as CodecParamsDescriptor, p as createCodecRegistry, r as CodecId, s as CodecRegistry, t as Codec, u as ExtractCodecTypes } from "./codec-types-B2Xdq0Wr.mjs";
-import { $ as ToWhereExpr, A as InsertOnConflict, B as NotExpr, C as ExistsExpr, D as ExpressionSource, E as ExpressionRewriter, F as JsonObjectEntry, G as ParamRef, H as OperationExpr, I as JsonObjectExpr, J as SelectAst, K as ProjectionExpr, L as ListExpression, M as JoinAst, N as JoinOnExpr, O as IdentifierRef, P as JsonArrayAggExpr, Q as TableSource, R as LiteralExpr, S as EqColJoinOn, T as ExpressionFolder, U as OrExpr, V as NullCheckExpr, W as OrderByItem, X as SubqueryExpr, Y as SelectAstOptions, Z as TableRef, _ as DeleteAst, a as AndExpr, at as whereExprKinds, b as DoNothingConflictAction, c as AnyInsertOnConflictAction, d as AnyQueryAst, et as UpdateAst, f as AstRewriter, g as DefaultValueExpr, h as ColumnRef, i as AggregateOpFn, it as queryAstKinds, j as InsertValue, k as InsertAst, l as AnyInsertValue, m as BinaryOp, n as AggregateExpr, nt as isQueryAst, o as AnyExpression, p as BinaryExpr, q as ProjectionItem, r as AggregateFn, rt as isWhereExpr, s as AnyFromSource, t as AggregateCountFn, tt as WhereArg, u as AnyOperationArg, v as DerivedTableSource, w as ExprVisitor, x as DoUpdateSetConflictAction, y as Direction, z as LoweredStatement } from "./types-C3Hg-CVz.mjs";
-import { Adapter, AdapterProfile, AdapterTarget, Lowerer, LowererContext, MarkerStatement, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCodecTypes, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, SqlQueryable, SqlTransaction, compact, sqlCodecDefinitions, sqlDataTypes } from "./exports/ast.mjs";
-import { n as augmentDescriptorWithColumnMeta, t as SqlQueryPlan } from "./plan-Cs65hb-E.mjs";
-import { a as JsonSchemaValidationResult, c as MutationDefaultsOptions, i as JsonSchemaValidationError, l as TypeHelperRegistry, n as ExecutionContext, o as JsonSchemaValidatorRegistry, r as JsonSchemaValidateFn, s as MutationDefaultsOp, t as AppliedMutationDefault } from "./query-lane-context-D2H78Mg0.mjs";
-import { C as TableDef, E as TablesOf, S as SqlPlan, T as TableMetadata, _ as RawTemplateFactory, a as ComputeColumnJsType, b as RuntimeError, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnsOf, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as Expr, p as OperationTypes, r as CodecTypes, s as HasIncludeManyCapabilities, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TableKey, x as SqlBuilderOptions, y as ResultType } from "./types-D3vVZzRZ.mjs";
-import { n as planUnsupported, t as planInvalid } from "./errors-DI_RVH66.mjs";
-import "./exports/plan.mjs";
-import "./exports/query-lane-context.mjs";
-import "./exports/types.mjs";
-export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyOperationArg, AnyQueryAst, AppliedMutationDefault, AstRewriter, BinaryExpr, BinaryOp, BuildOptions, BuildParamsMap, Codec, CodecDefBuilder, CodecId, CodecInput, CodecMeta, CodecParamsDescriptor, CodecRegistry, CodecTrait, CodecTraits, CodecTypes, ColumnRef, ColumnsOf, ComputeColumnJsType, DefaultValueExpr, DeleteAst, DerivedTableSource, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ExtractDataTypes, HasIncludeManyCapabilities, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonObjectEntry, JsonObjectExpr, JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult, JsonSchemaValidatorRegistry, ListExpression, LiteralExpr, LoweredStatement, Lowerer, LowererContext, META, MarkerStatement, Meta, ModelDef, ModelMetadata, MutationDefaultsOp, MutationDefaultsOptions, NotExpr, NullCheckExpr, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderByItem, ParamRef, ProjectionExpr, ProjectionItem, RawFactory, RawFunctionOptions, RawTemplateFactory, RawTemplateOptions, ResultType, RuntimeError, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SelectAstOptions, SqlBuilderOptions, SqlCodecTypes, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlPlan, SqlQueryPlan, SqlQueryResult, SqlQueryable, SqlTransaction, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TypeHelperRegistry, UpdateAst, WhereArg, augmentDescriptorWithColumnMeta, codec, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, planInvalid, planUnsupported, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
+import { $ as TableRef, A as InsertOnConflict, B as NotExpr, C as ExistsExpr, D as ExpressionSource, E as ExpressionRewriter, F as JsonObjectEntry, G as ParamRef, H as OperationExpr, I as JsonObjectExpr, J as ProjectionItem, K as ParamRefBindingRefs, L as ListExpression, M as JoinAst, N as JoinOnExpr, O as IdentifierRef, P as JsonArrayAggExpr, Q as SubqueryExpr, R as LiteralExpr, S as EqColJoinOn, T as ExpressionFolder, U as OrExpr, V as NullCheckExpr, W as OrderByItem, X as SelectAst, Y as RawSqlExpr, Z as SelectAstOptions, _ as DeleteAst, a as AndExpr, at as isWhereExpr, b as DoNothingConflictAction, c as AnyInsertOnConflictAction, d as AnyQueryAst, et as TableSource, f as AstRewriter, g as DefaultValueExpr, h as ColumnRef, i as AggregateOpFn, it as isQueryAst, j as InsertValue, k as InsertAst, l as AnyInsertValue, m as BinaryOp, n as AggregateExpr, nt as UpdateAst, o as AnyExpression, ot as queryAstKinds, p as BinaryExpr, q as ProjectionExpr, r as AggregateFn, rt as WhereArg, s as AnyFromSource, st as whereExprKinds, t as AggregateCountFn, tt as ToWhereExpr, u as AnyOperationArg, v as DerivedTableSource, w as ExprVisitor, x as DoUpdateSetConflictAction, y as Direction, z as LoweredStatement } from "./types-BZcKgaYA.mjs";
+import { a as CodecMeta, c as DescriptorCodecId, d as ExtractCodecTypes, f as SqlCodecCallContext, i as CodecDescriptor, l as DescriptorCodecInput, m as SqlColumnRef, n as Codec, o as CodecTrait, p as SqlCodecInstanceContext, r as CodecCallContext, s as ContractCodecRegistry, t as AnyCodecDescriptor, u as DescriptorCodecTraits } from "./codec-types-BUfBna4G.mjs";
+import { a as MutationDefaultsOptions, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as TypeHelperRegistry, r as ExecutionContext, t as AppliedMutationDefault } from "./query-lane-context-C2tLZGp4.mjs";
+import { Adapter, AdapterProfile, AdapterTarget, Lowerer, LowererContext, MarkerStatement, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCharCodec, SqlCharDescriptor, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, collectOrderedParamRefs, compact, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, validateParamRefRefs } from "./exports/ast.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-ffz8TSfr.mjs";
+import { C as TableKey, S as TableDef, T as TablesOf, _ as RawTemplateFactory, a as ComputeColumnJsType, b as SqlBuilderOptions, c as META, d as ModelMetadata, f as OperationTypeSignature, g as RawFunctionOptions, h as RawFactory, i as ColumnsOf, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as Expr, p as OperationTypes, r as CodecTypes, s as HasIncludeManyCapabilities, t as BuildOptions, u as ModelDef, v as RawTemplateOptions, w as TableMetadata, x as SqlPlan, y as RuntimeError } from "./types-D6Pk1DTr.mjs";
+import { n as planUnsupported, t as planInvalid } from "./errors-BgNpVAT8.mjs";
+import { BuildOperationSpec, CodecExpression, Expression, ScopeField, TraitExpression, buildOperation, refsOf, toExpr } from "./exports/expression.mjs";
+import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-USDeR8p1.mjs";
+import { n as planFromAst, t as SqlQueryPlan } from "./plan-DFpOIsKB.mjs";
+import { n as SqlOrmPlan, t as RuntimeScope } from "./types-CL18G37a.mjs";
+export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyOperationArg, AnyQueryAst, AppliedMutationDefault, AstRewriter, BinaryExpr, BinaryOp, BuildOperationSpec, BuildOptions, BuildParamsMap, Codec, CodecCallContext, CodecDescriptor, CodecDescriptorRegistry, CodecExpression, CodecMeta, CodecTrait, CodecTypes, ColumnRef, ColumnsOf, ComputeColumnJsType, ContractCodecRegistry, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, Expression, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, HasIncludeManyCapabilities, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonObjectEntry, JsonObjectExpr, ListExpression, LiteralExpr, LoweredStatement, Lowerer, LowererContext, META, MarkerStatement, Meta, ModelDef, ModelMetadata, MutationDefaultsOp, MutationDefaultsOptions, NotExpr, NullCheckExpr, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderByItem, ParamRef, ParamRefBindingRefs, ParamRefEntry, ParamRefEntryUnion, ParamRefHandle, ProjectionExpr, ProjectionItem, RawFactory, RawFunctionOptions, RawSqlExpr, RawTemplateFactory, RawTemplateOptions, RuntimeError, RuntimeScope, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, ScopeField, SelectAst, SelectAstOptions, SqlBuilderOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExecutionPlan, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlOrmPlan, SqlParamRefMutator, SqlParamRefMutatorInternal, SqlPlan, SqlQueryPlan, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TraitExpression, TypeHelperRegistry, UpdateAst, WhereArg, buildOperation, collectOrderedParamRefs, compact, createSqlParamRefMutator, isQueryAst, isWhereExpr, planFromAst, planInvalid, planUnsupported, queryAstKinds, refsOf, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, validateParamRefRefs, whereExprKinds };

package/dist/index.mjs

@@ -1,7 +1,10 @@
-import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SubqueryExpr, TableSource, UpdateAst, codec, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds } from "./exports/ast.mjs";
-import { n as planUnsupported, t as planInvalid } from "./errors-D3xmG4h-.mjs";
-import { augmentDescriptorWithColumnMeta } from "./exports/plan.mjs";
+import { A as TableSource, C as OrExpr, D as RawSqlExpr, E as ProjectionItem, F as whereExprKinds, M as isQueryAst, N as isWhereExpr, O as SelectAst, P as queryAstKinds, S as OperationExpr, T as ParamRef, _ as JsonObjectExpr, a as DefaultValueExpr, b as NotExpr, c as DoNothingConflictAction, d as ExistsExpr, f as IdentifierRef, g as JsonArrayAggExpr, h as JoinAst, i as ColumnRef, j as UpdateAst, k as SubqueryExpr, l as DoUpdateSetConflictAction, m as InsertOnConflict, n as AndExpr, o as DeleteAst, p as InsertAst, r as BinaryExpr, s as DerivedTableSource, t as AggregateExpr, u as EqColJoinOn, v as ListExpression, w as OrderByItem, x as NullCheckExpr, y as LiteralExpr } from "./types-CK9ZJ6OU.mjs";
+import { n as compact, t as collectOrderedParamRefs } from "./util-DWmhUCEO.mjs";
+import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, validateParamRefRefs } from "./exports/ast.mjs";
+import { n as planUnsupported, t as planInvalid } from "./errors-BF7W5uUd.mjs";
+import { buildOperation, refsOf, toExpr } from "./exports/expression.mjs";
+import { t as createSqlParamRefMutator } from "./middleware-D2Wv9QIf.mjs";
+import { planFromAst } from "./exports/plan.mjs";
 import "./exports/query-lane-context.mjs";
 import "./exports/types.mjs";
-
-export { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SubqueryExpr, TableSource, UpdateAst, augmentDescriptorWithColumnMeta, codec, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, planInvalid, planUnsupported, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
+export { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, RawSqlExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UpdateAst, buildOperation, collectOrderedParamRefs, compact, createSqlParamRefMutator, isQueryAst, isWhereExpr, planFromAst, planInvalid, planUnsupported, queryAstKinds, refsOf, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, validateParamRefRefs, whereExprKinds };

package/dist/middleware-D2Wv9QIf.mjs

@@ -0,0 +1,82 @@
+import { t as collectOrderedParamRefs } from "./util-DWmhUCEO.mjs";
+//#region src/middleware/param-ref-mutator.ts
+/**
+* Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.
+*
+* The mutator captures `plan.params` by reference and walks
+* `plan.ast` (via `collectOrderedParamRefs`) on demand to build
+* entries. Mutations write to a lazily-allocated working copy so the
+* fast path (no mutation) preserves bit-for-bit reference identity to
+* the original `plan.params`.
+*
+* Threading: `plan.ast` carries the canonical `ParamRef` ordering used
+* by every consumer (renderer's `$N` index map, encode-side metadata
+* walk, etc.). The mutator's `entries()` yields the same order so
+* middleware that filters by codec id sees ParamRefs in the order the
+* runtime will encode them.
+*/
+function createSqlParamRefMutator(plan) {
+	const originalParams = plan.params;
+	const refs = plan.ast ? collectOrderedParamRefs(plan.ast) : [];
+	let workingParams;
+	const indexOfRef = (handle) => {
+		return refs.indexOf(handle);
+	};
+	const ensureWorkingParams = () => {
+		if (!workingParams) workingParams = [...originalParams];
+		return workingParams;
+	};
+	const writeAt = (index, value) => {
+		const buffer = ensureWorkingParams();
+		buffer[index] = value;
+	};
+	function* entries() {
+		const view = workingParams ?? originalParams;
+		for (let i = 0; i < refs.length; i++) {
+			const ref = refs[i];
+			if (!ref) continue;
+			const handle = ref;
+			const value = i < view.length ? view[i] : ref.value;
+			const codecId = ref.codecId;
+			const column = ref.refs ? {
+				table: ref.refs.table,
+				name: ref.refs.column
+			} : void 0;
+			yield column ? {
+				ref: handle,
+				value,
+				codecId,
+				column
+			} : {
+				ref: handle,
+				value,
+				codecId
+			};
+		}
+	}
+	function replaceValue(handle, newValue) {
+		const index = indexOfRef(handle);
+		if (index < 0) return;
+		writeAt(index, newValue);
+	}
+	function replaceValues(updates) {
+		for (const { ref, newValue } of updates) {
+			const index = indexOfRef(ref);
+			if (index < 0) continue;
+			writeAt(index, newValue);
+		}
+	}
+	return {
+		entries,
+		replaceValue,
+		replaceValues,
+		currentParams() {
+			if (!workingParams) return originalParams;
+			return Object.freeze([...workingParams]);
+		}
+	};
+}
+//#endregion
+export { createSqlParamRefMutator as t };
+
+//# sourceMappingURL=middleware-D2Wv9QIf.mjs.map

package/dist/middleware-D2Wv9QIf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-D2Wv9QIf.mjs","names":[],"sources":["../src/middleware/param-ref-mutator.ts"],"sourcesContent":["import type { ParamRefMutator } from '@prisma-next/framework-components/runtime';\nimport type { SqlColumnRef } from '../ast/codec-types';\nimport type { ParamRef } from '../ast/types';\nimport { collectOrderedParamRefs } from '../ast/util';\nimport type { SqlExecutionPlan } from '../sql-execution-plan';\n\n/**\n * Brand applied to {@link ParamRefHandle} so user-constructed handles\n * are rejected by the type system. The mutator only accepts handles it\n * produced from `entries()`.\n *\n * The brand is a phantom type — there is no runtime token. At runtime\n * the handle is the underlying `ParamRef` instance from the plan's\n * `ast`; the brand only narrows the type-level surface so callers\n * cannot fabricate a handle from a fresh `ParamRef.of(...)`.\n */\ndeclare const paramRefHandleBrand: unique symbol;\n\n/**\n * Opaque token identifying a single `ParamRef` in the plan. Produced by\n * {@link SqlParamRefMutator.entries}; consumed by `replaceValue` /\n * `replaceValues`.\n *\n * The phantom `TCodecId` parameter records the codec id of the\n * referenced `ParamRef` so type-level inference can route replacement\n * values through `TCodecMap` to the codec's declared `TInput`.\n */\nexport interface ParamRefHandle<TCodecId extends string | undefined = string | undefined> {\n  readonly [paramRefHandleBrand]: TCodecId;\n}\n\n/**\n * One outbound `ParamRef` slot in the plan exposed to middleware.\n * `value` is the current value (post any prior middleware mutations);\n * `codecId` is the codec id declared on the underlying `ParamRef`;\n * `column` is populated for `ParamRef`s the lowering site could resolve\n * to a single `(table, column)` via `ParamRef.refs` (encode-side column\n * metadata is the middleware's domain — encode itself currently leaves\n * `ctx.column` unset).\n */\nexport interface ParamRefEntry<TCodecId extends string | undefined = string | undefined> {\n  readonly ref: ParamRefHandle<TCodecId>;\n  readonly value: unknown;\n  readonly codecId: TCodecId;\n  readonly column?: SqlColumnRef;\n}\n\n/**\n * Discriminated entry union over a codec map. For each `K` in\n * `TCodecMap`, `entries()` may yield a `ParamRefEntry<K>`; ParamRefs\n * with no codec id (or a codec id outside the map) yield a\n * `ParamRefEntry<undefined>`. Pattern-matching on `entry.codecId`\n * narrows `entry.ref` to a `ParamRefHandle<K>`, which routes through\n * the typed `replaceValue` overload.\n */\nexport type ParamRefEntryUnion<TCodecMap extends Record<string, unknown>> =\n  | { [K in keyof TCodecMap & string]: ParamRefEntry<K> }[keyof TCodecMap & string]\n  | ParamRefEntry<undefined>;\n\n/**\n * SQL-family mutator threaded into `SqlMiddleware.beforeExecute` as\n * `params`. Scope is `ParamRef.value` slots only — middleware cannot\n * insert / remove `ParamRef`s, rewrite SQL, or modify projection. The\n * type-level `ParamRefHandle` brand and the `replaceValue(ref,\n * newValue)` shape enforce this at compile time.\n *\n * Allocation discipline: the mutator is constructed lazily from the\n * plan. `entries()` walks the plan's existing AST without allocating\n * an intermediate array; the working params buffer is only allocated\n * on the first `replaceValue` / `replaceValues` call. If no middleware\n * mutates, `currentParams()` returns the plan's original `params` by\n * reference identity.\n *\n * The `TCodecMap` parameter is a record keyed by codec id; `replaceValue`\n * infers `newValue` from `TCodecMap[H['codecId']]` for handles whose\n * codec id is statically resolvable. For codec ids the type system\n * cannot resolve, `newValue` falls back to `unknown` and the middleware\n * is on the hook for runtime correctness.\n */\nexport interface SqlParamRefMutator<\n  TCodecMap extends Record<string, unknown> = Record<string, unknown>,\n> extends ParamRefMutator {\n  /** Iterate every outbound `ParamRef` the plan currently carries, in canonical order. */\n  entries(): IterableIterator<ParamRefEntryUnion<TCodecMap>>;\n\n  /**\n   * Replace one `ParamRef`'s value with the result of bulk processing.\n   * `newValue` is constrained to the codec's declared `TInput` for codec\n   * ids the type system can resolve via `TCodecMap`; for unresolvable\n   * codec ids `newValue` is `unknown` (the second overload).\n   */\n  replaceValue<TCodecId extends keyof TCodecMap & string>(\n    ref: ParamRefHandle<TCodecId>,\n    newValue: TCodecMap[TCodecId],\n  ): void;\n  replaceValue(ref: ParamRefHandle<undefined>, newValue: unknown): void;\n\n  /** Replace many at once (typical for bulk-pattern middleware). */\n  replaceValues(\n    updates: Iterable<{\n      readonly ref: ParamRefHandle<(keyof TCodecMap & string) | undefined>;\n      readonly newValue: unknown;\n    }>,\n  ): void;\n}\n\n/**\n * Internal-only view of the mutator that exposes the post-mutation params\n * array to the SQL runtime. The runtime calls `currentParams()` after the\n * `beforeExecute` chain has run; the result is the plan's original\n * `params` by reference identity if no middleware mutated, otherwise a\n * frozen new array carrying the mutations applied in chain order.\n *\n * Family-internal contract — `SqlMiddleware` consumers never see this\n * shape; they receive the public `SqlParamRefMutator` view above.\n */\nexport interface SqlParamRefMutatorInternal<\n  TCodecMap extends Record<string, unknown> = Record<string, unknown>,\n> extends SqlParamRefMutator<TCodecMap> {\n  currentParams(): readonly unknown[];\n}\n\ntype AnyHandle = ParamRefHandle<string | undefined>;\n\n/**\n * Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.\n *\n * The mutator captures `plan.params` by reference and walks\n * `plan.ast` (via `collectOrderedParamRefs`) on demand to build\n * entries. Mutations write to a lazily-allocated working copy so the\n * fast path (no mutation) preserves bit-for-bit reference identity to\n * the original `plan.params`.\n *\n * Threading: `plan.ast` carries the canonical `ParamRef` ordering used\n * by every consumer (renderer's `$N` index map, encode-side metadata\n * walk, etc.). The mutator's `entries()` yields the same order so\n * middleware that filters by codec id sees ParamRefs in the order the\n * runtime will encode them.\n */\nexport function createSqlParamRefMutator<\n  TCodecMap extends Record<string, unknown> = Record<string, unknown>,\n>(plan: SqlExecutionPlan): SqlParamRefMutatorInternal<TCodecMap> {\n  const originalParams = plan.params;\n  const refs: ReadonlyArray<ParamRef> = plan.ast ? collectOrderedParamRefs(plan.ast) : [];\n  let workingParams: unknown[] | undefined;\n\n  const indexOfRef = (handle: AnyHandle): number => {\n    // The handle is the underlying ParamRef instance the mutator yielded\n    // from entries(); equality is identity equality on the ParamRef. The\n    // brand on ParamRefHandle is unforgeable from outside, so the only\n    // legal handles came from this mutator's entries().\n    return refs.indexOf(handle as unknown as ParamRef);\n  };\n\n  const ensureWorkingParams = (): unknown[] => {\n    if (!workingParams) {\n      workingParams = [...originalParams];\n    }\n    return workingParams;\n  };\n\n  const writeAt = (index: number, value: unknown): void => {\n    const buffer = ensureWorkingParams();\n    buffer[index] = value;\n  };\n\n  function* entries(): IterableIterator<ParamRefEntryUnion<TCodecMap>> {\n    const view = workingParams ?? originalParams;\n    for (let i = 0; i < refs.length; i++) {\n      const ref = refs[i];\n      if (!ref) continue;\n      const handle = ref as unknown as ParamRefHandle<string | undefined>;\n      const value = i < view.length ? view[i] : ref.value;\n      const codecId = ref.codecId;\n      // Surface the column binding the lowering site resolved onto\n      // `ParamRef.refs` so column-aware middleware (e.g. cipherstash\n      // routing-key resolution) can address the cell without\n      // re-walking the AST. ParamRefs without a column binding stay\n      // `column: undefined`.\n      const column = ref.refs\n        ? ({ table: ref.refs.table, name: ref.refs.column } as const)\n        : undefined;\n      // The runtime erases the discriminated union to a single shape; the\n      // public type pins each entry's `ref` to the matching `codecId`\n      // arm at compile time.\n      const entry: ParamRefEntry<string | undefined> = column\n        ? { ref: handle, value, codecId, column }\n        : { ref: handle, value, codecId };\n      yield entry as ParamRefEntryUnion<TCodecMap>;\n    }\n  }\n\n  function replaceValue(handle: AnyHandle, newValue: unknown): void {\n    const index = indexOfRef(handle);\n    if (index < 0) {\n      // Handle does not belong to this plan. The type system pins this\n      // at the brand level; this runtime check guards against handles\n      // smuggled across plans.\n      return;\n    }\n    writeAt(index, newValue);\n  }\n\n  function replaceValues(\n    updates: Iterable<{ readonly ref: AnyHandle; readonly newValue: unknown }>,\n  ): void {\n    for (const { ref, newValue } of updates) {\n      const index = indexOfRef(ref);\n      if (index < 0) continue;\n      writeAt(index, newValue);\n    }\n  }\n\n  // The public `SqlParamRefMutator` declares overloaded `replaceValue`\n  // signatures (typed-by-codec / unresolvable-codec). The implementation\n  // is one function with a permissive runtime signature; the cast is the\n  // single point at which the runtime function meets the typed overload\n  // surface, matching the overload-implementation pattern.\n  return {\n    entries,\n    replaceValue: replaceValue as SqlParamRefMutator<TCodecMap>['replaceValue'],\n    replaceValues,\n    currentParams(): readonly unknown[] {\n      if (!workingParams) {\n        return originalParams;\n      }\n      return Object.freeze([...workingParams]);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA2IA,SAAgB,yBAEd,MAA+D;CAC/D,MAAM,iBAAiB,KAAK;CAC5B,MAAM,OAAgC,KAAK,MAAM,wBAAwB,KAAK,IAAI,GAAG,EAAE;CACvF,IAAI;CAEJ,MAAM,cAAc,WAA8B;EAKhD,OAAO,KAAK,QAAQ,OAA8B;;CAGpD,MAAM,4BAAuC;EAC3C,IAAI,CAAC,eACH,gBAAgB,CAAC,GAAG,eAAe;EAErC,OAAO;;CAGT,MAAM,WAAW,OAAe,UAAyB;EACvD,MAAM,SAAS,qBAAqB;EACpC,OAAO,SAAS;;CAGlB,UAAU,UAA2D;EACnE,MAAM,OAAO,iBAAiB;EAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,MAAM,KAAK;GACjB,IAAI,CAAC,KAAK;GACV,MAAM,SAAS;GACf,MAAM,QAAQ,IAAI,KAAK,SAAS,KAAK,KAAK,IAAI;GAC9C,MAAM,UAAU,IAAI;GAMpB,MAAM,SAAS,IAAI,OACd;IAAE,OAAO,IAAI,KAAK;IAAO,MAAM,IAAI,KAAK;IAAQ,GACjD,KAAA;GAOJ,MAHiD,SAC7C;IAAE,KAAK;IAAQ;IAAO;IAAS;IAAQ,GACvC;IAAE,KAAK;IAAQ;IAAO;IAAS;;;CAKvC,SAAS,aAAa,QAAmB,UAAyB;EAChE,MAAM,QAAQ,WAAW,OAAO;EAChC,IAAI,QAAQ,GAIV;EAEF,QAAQ,OAAO,SAAS;;CAG1B,SAAS,cACP,SACM;EACN,KAAK,MAAM,EAAE,KAAK,cAAc,SAAS;GACvC,MAAM,QAAQ,WAAW,IAAI;GAC7B,IAAI,QAAQ,GAAG;GACf,QAAQ,OAAO,SAAS;;;CAS5B,OAAO;EACL;EACc;EACd;EACA,gBAAoC;GAClC,IAAI,CAAC,eACH,OAAO;GAET,OAAO,OAAO,OAAO,CAAC,GAAG,cAAc,CAAC;;EAE3C"}

package/dist/middleware-USDeR8p1.d.mts

@@ -0,0 +1,121 @@
+import { m as SqlColumnRef } from "./codec-types-BUfBna4G.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-ffz8TSfr.mjs";
+import { ParamRefMutator } from "@prisma-next/framework-components/runtime";
+
+//#region src/middleware/param-ref-mutator.d.ts
+/**
+ * Brand applied to {@link ParamRefHandle} so user-constructed handles
+ * are rejected by the type system. The mutator only accepts handles it
+ * produced from `entries()`.
+ *
+ * The brand is a phantom type — there is no runtime token. At runtime
+ * the handle is the underlying `ParamRef` instance from the plan's
+ * `ast`; the brand only narrows the type-level surface so callers
+ * cannot fabricate a handle from a fresh `ParamRef.of(...)`.
+ */
+declare const paramRefHandleBrand: unique symbol;
+/**
+ * Opaque token identifying a single `ParamRef` in the plan. Produced by
+ * {@link SqlParamRefMutator.entries}; consumed by `replaceValue` /
+ * `replaceValues`.
+ *
+ * The phantom `TCodecId` parameter records the codec id of the
+ * referenced `ParamRef` so type-level inference can route replacement
+ * values through `TCodecMap` to the codec's declared `TInput`.
+ */
+interface ParamRefHandle<TCodecId extends string | undefined = string | undefined> {
+  readonly [paramRefHandleBrand]: TCodecId;
+}
+/**
+ * One outbound `ParamRef` slot in the plan exposed to middleware.
+ * `value` is the current value (post any prior middleware mutations);
+ * `codecId` is the codec id declared on the underlying `ParamRef`;
+ * `column` is populated for `ParamRef`s the lowering site could resolve
+ * to a single `(table, column)` via `ParamRef.refs` (encode-side column
+ * metadata is the middleware's domain — encode itself currently leaves
+ * `ctx.column` unset).
+ */
+interface ParamRefEntry<TCodecId extends string | undefined = string | undefined> {
+  readonly ref: ParamRefHandle<TCodecId>;
+  readonly value: unknown;
+  readonly codecId: TCodecId;
+  readonly column?: SqlColumnRef;
+}
+/**
+ * Discriminated entry union over a codec map. For each `K` in
+ * `TCodecMap`, `entries()` may yield a `ParamRefEntry<K>`; ParamRefs
+ * with no codec id (or a codec id outside the map) yield a
+ * `ParamRefEntry<undefined>`. Pattern-matching on `entry.codecId`
+ * narrows `entry.ref` to a `ParamRefHandle<K>`, which routes through
+ * the typed `replaceValue` overload.
+ */
+type ParamRefEntryUnion<TCodecMap extends Record<string, unknown>> = { [K in keyof TCodecMap & string]: ParamRefEntry<K> }[keyof TCodecMap & string] | ParamRefEntry<undefined>;
+/**
+ * SQL-family mutator threaded into `SqlMiddleware.beforeExecute` as
+ * `params`. Scope is `ParamRef.value` slots only — middleware cannot
+ * insert / remove `ParamRef`s, rewrite SQL, or modify projection. The
+ * type-level `ParamRefHandle` brand and the `replaceValue(ref,
+ * newValue)` shape enforce this at compile time.
+ *
+ * Allocation discipline: the mutator is constructed lazily from the
+ * plan. `entries()` walks the plan's existing AST without allocating
+ * an intermediate array; the working params buffer is only allocated
+ * on the first `replaceValue` / `replaceValues` call. If no middleware
+ * mutates, `currentParams()` returns the plan's original `params` by
+ * reference identity.
+ *
+ * The `TCodecMap` parameter is a record keyed by codec id; `replaceValue`
+ * infers `newValue` from `TCodecMap[H['codecId']]` for handles whose
+ * codec id is statically resolvable. For codec ids the type system
+ * cannot resolve, `newValue` falls back to `unknown` and the middleware
+ * is on the hook for runtime correctness.
+ */
+interface SqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends ParamRefMutator {
+  /** Iterate every outbound `ParamRef` the plan currently carries, in canonical order. */
+  entries(): IterableIterator<ParamRefEntryUnion<TCodecMap>>;
+  /**
+   * Replace one `ParamRef`'s value with the result of bulk processing.
+   * `newValue` is constrained to the codec's declared `TInput` for codec
+   * ids the type system can resolve via `TCodecMap`; for unresolvable
+   * codec ids `newValue` is `unknown` (the second overload).
+   */
+  replaceValue<TCodecId extends keyof TCodecMap & string>(ref: ParamRefHandle<TCodecId>, newValue: TCodecMap[TCodecId]): void;
+  replaceValue(ref: ParamRefHandle<undefined>, newValue: unknown): void;
+  /** Replace many at once (typical for bulk-pattern middleware). */
+  replaceValues(updates: Iterable<{
+    readonly ref: ParamRefHandle<(keyof TCodecMap & string) | undefined>;
+    readonly newValue: unknown;
+  }>): void;
+}
+/**
+ * Internal-only view of the mutator that exposes the post-mutation params
+ * array to the SQL runtime. The runtime calls `currentParams()` after the
+ * `beforeExecute` chain has run; the result is the plan's original
+ * `params` by reference identity if no middleware mutated, otherwise a
+ * frozen new array carrying the mutations applied in chain order.
+ *
+ * Family-internal contract — `SqlMiddleware` consumers never see this
+ * shape; they receive the public `SqlParamRefMutator` view above.
+ */
+interface SqlParamRefMutatorInternal<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends SqlParamRefMutator<TCodecMap> {
+  currentParams(): readonly unknown[];
+}
+/**
+ * Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.
+ *
+ * The mutator captures `plan.params` by reference and walks
+ * `plan.ast` (via `collectOrderedParamRefs`) on demand to build
+ * entries. Mutations write to a lazily-allocated working copy so the
+ * fast path (no mutation) preserves bit-for-bit reference identity to
+ * the original `plan.params`.
+ *
+ * Threading: `plan.ast` carries the canonical `ParamRef` ordering used
+ * by every consumer (renderer's `$N` index map, encode-side metadata
+ * walk, etc.). The mutator's `entries()` yields the same order so
+ * middleware that filters by codec id sees ParamRefs in the order the
+ * runtime will encode them.
+ */
+declare function createSqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>>(plan: SqlExecutionPlan): SqlParamRefMutatorInternal<TCodecMap>;
+//#endregion
+export { SqlParamRefMutatorInternal as a, SqlParamRefMutator as i, ParamRefEntryUnion as n, createSqlParamRefMutator as o, ParamRefHandle as r, ParamRefEntry as t };
+//# sourceMappingURL=middleware-USDeR8p1.d.mts.map

package/dist/middleware-USDeR8p1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-USDeR8p1.d.mts","names":[],"sources":["../src/middleware/param-ref-mutator.ts"],"mappings":";;;;;;;AAI8D;;;;;AAuB9D;;;cAXc,mBAAA;;;;;;AAwBd;;;;UAbiB,cAAA;EAAA,UACL,mBAAA,GAAsB,QAAA;AAAA;;;;;;;;;;UAYjB,aAAA;EAAA,SACN,GAAA,EAAK,cAAA,CAAe,QAAA;EAAA,SACpB,KAAA;EAAA,SACA,OAAA,EAAS,QAAA;EAAA,SACT,MAAA,GAAS,YAAA;AAAA;;;;;;;;;KAWR,kBAAA,mBAAqC,MAAA,mCAC/B,SAAA,YAAqB,aAAA,CAAc,CAAA,UAAW,SAAA,aAC5D,aAAA;;;;;;;;;AAsBJ;;;;;;;;;;;;UAAiB,kBAAA,mBACG,MAAA,oBAA0B,MAAA,2BACpC,eAAA;EAcU;EAZlB,OAAA,IAAW,gBAAA,CAAiB,kBAAA,CAAmB,SAAA;EAiB7B;;;;;;EATlB,YAAA,wBAAoC,SAAA,WAClC,GAAA,EAAK,cAAA,CAAe,QAAA,GACpB,QAAA,EAAU,SAAA,CAAU,QAAA;EAEtB,YAAA,CAAa,GAAA,EAAK,cAAA,aAA2B,QAAA;EAdrC;EAiBR,aAAA,CACE,OAAA,EAAS,QAAA;IAAA,SACE,GAAA,EAAK,cAAA,QAAsB,SAAA;IAAA,SAC3B,QAAA;EAAA;AAAA;;;;;;;;;;;UAeE,0BAAA,mBACG,MAAA,oBAA0B,MAAA,2BACpC,kBAAA,CAAmB,SAAA;EAC3B,aAAA;AAAA;;;;;;;;;AAHF;;;;;;;iBAuBgB,wBAAA,mBACI,MAAA,oBAA0B,MAAA,kBAAA,CAC5C,IAAA,EAAM,gBAAA,GAAmB,0BAAA,CAA2B,SAAA"}

package/dist/plan-DFpOIsKB.d.mts

@@ -0,0 +1,44 @@
+import { d as AnyQueryAst } from "./types-BZcKgaYA.mjs";
+import { QueryPlan } from "@prisma-next/framework-components/runtime";
+import { Contract } from "@prisma-next/contract/types";
+import { SqlStorage } 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 — `RuntimeCore` (the runtime base class in
+ * `@prisma-next/framework-components/runtime`) drives lowering via the
+ * SQL adapter and produces a `SqlExecutionPlan`.
+ *
+ * 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.
+ */
+interface SqlQueryPlan<Row = unknown> extends QueryPlan<Row> {
+  readonly ast: AnyQueryAst;
+  readonly params: readonly unknown[];
+}
+/**
+ * Wraps an `AnyQueryAst` (typically a `RawSqlExpr` constructed package-internally
+ * by an extension's migration factory) in a fully-populated `SqlQueryPlan`
+ * whose `meta` is sourced from the supplied contract.
+ *
+ * Centralising the envelope here means consumers (cipherstash migration
+ * factories today; future raw-sql callers) cannot drift on `storageHash` /
+ * `target` / `targetFamily`, which would otherwise surface as a subtle
+ * `assertContractMatches` failure inside `dataTransform`. `params` defaults
+ * to `[]` because parameters embedded in the AST as `ParamRef`s are resolved
+ * at lowering time (`encodeParams` walks `plan.ast.collectParamRefs()`),
+ * not at plan-construction time.
+ *
+ * The default `laneId` of `'raw'` reflects raw-SQL plans' standard lane tag;
+ * callers (e.g. a future `sql-raw-factory`) may override to differentiate
+ * the plan's provenance.
+ */
+declare function planFromAst<Row = unknown>(ast: AnyQueryAst, contract: Contract<SqlStorage>, laneId?: string): SqlQueryPlan<Row>;
+//#endregion
+export { planFromAst as n, SqlQueryPlan as t };
+//# sourceMappingURL=plan-DFpOIsKB.d.mts.map

package/dist/plan-DFpOIsKB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-DFpOIsKB.d.mts","names":[],"sources":["../src/plan.ts"],"mappings":";;;;;;;;AAkBA;;;;;;;;;;;UAAiB,YAAA,wBAAoC,SAAA,CAAU,GAAA;EAAA,SACpD,GAAA,EAAK,WAAA;EAAA,SACL,MAAA;AAAA;;AAoBX;;;;;;;;;;;;;;;;iBAAgB,WAAA,eAAA,CACd,GAAA,EAAK,WAAA,EACL,QAAA,EAAU,QAAA,CAAS,UAAA,GACnB,MAAA,YACC,YAAA,CAAa,GAAA"}

package/dist/query-lane-context-C2tLZGp4.d.mts

@@ -0,0 +1,72 @@
+import { s as ContractCodecRegistry } from "./codec-types-BUfBna4G.mjs";
+import { CodecDescriptor } from "@prisma-next/framework-components/codec";
+import { Contract } from "@prisma-next/contract/types";
+import { SqlOperationRegistry } from "@prisma-next/sql-operations";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+
+//#region src/query-lane-context.d.ts
+/**
+ * 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).
+ */
+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>[];
+}
+/**
+ * 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).
+ */
+type TypeHelperRegistry = Record<string, unknown>;
+type MutationDefaultsOp = 'create' | 'update';
+type AppliedMutationDefault = {
+  readonly column: string;
+  readonly value: unknown;
+};
+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.
+ */
+interface ExecutionContext<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
+  readonly contract: TContract;
+  /**
+   * 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 contractCodecs: ContractCodecRegistry;
+  /**
+   * 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 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).
+   */
+  applyMutationDefaults(options: MutationDefaultsOptions): ReadonlyArray<AppliedMutationDefault>;
+}
+//#endregion
+export { MutationDefaultsOptions as a, MutationDefaultsOp as i, CodecDescriptorRegistry as n, TypeHelperRegistry as o, ExecutionContext as r, AppliedMutationDefault as t };
+//# sourceMappingURL=query-lane-context-C2tLZGp4.d.mts.map

package/dist/query-lane-context-C2tLZGp4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-lane-context-C2tLZGp4.d.mts","names":[],"sources":["../src/query-lane-context.ts"],"mappings":";;;;;;;;;AASA;UAAiB,uBAAA;;;;EAIf,aAAA,CAAc,OAAA,WAAkB,eAAA;EAQW;;;EAJ3C,MAAA,IAAU,gBAAA,CAAiB,eAAA;EAJb;;;EAQd,YAAA,CAAa,UAAA,oBAA8B,eAAA;AAAA;;;;KAMjC,kBAAA,GAAqB,MAAA;AAAA,KAErB,kBAAA;AAAA,KAEA,sBAAA;EAAA,SACD,MAAA;EAAA,SACA,KAAA;AAAA;AAAA,KAGC,uBAAA;EAAA,SACD,EAAA,EAAI,kBAAA;EAAA,SACJ,KAAA;EAAA,SACA,MAAA,EAAQ,MAAA;EAVW;;AAE9B;;EAF8B,SAenB,iBAAA,GAAoB,GAAA;AAAA;;AAR/B;;;;UAgBiB,gBAAA,mBAAmC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,SACzE,QAAA,EAAU,SAAA;EATa;;;;EAAA,SAcvB,cAAA,EAAgB,qBAAA;EAnBhB;;;EAAA,SAuBA,gBAAA,EAAkB,uBAAA;EAAA,SAClB,eAAA,EAAiB,oBAAA;EAnBM;AAQlC;;EARkC,SAuBvB,KAAA,EAAO,kBAAA;EAf2C;;;EAmB3D,qBAAA,CAAsB,OAAA,EAAS,uBAAA,GAA0B,aAAA,CAAc,sBAAA;AAAA"}

package/dist/sql-execution-plan-ffz8TSfr.d.mts

@@ -0,0 +1,32 @@
+import { d as AnyQueryAst } from "./types-BZcKgaYA.mjs";
+import { ExecutionPlan } from "@prisma-next/framework-components/runtime";
+
+//#region src/sql-execution-plan.d.ts
+/**
+ * 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.
+ */
+interface SqlExecutionPlan<Row = unknown> extends ExecutionPlan<Row> {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+  readonly ast?: AnyQueryAst;
+}
+//#endregion
+export { SqlExecutionPlan as t };
+//# sourceMappingURL=sql-execution-plan-ffz8TSfr.d.mts.map

package/dist/sql-execution-plan-ffz8TSfr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-execution-plan-ffz8TSfr.d.mts","names":[],"sources":["../src/sql-execution-plan.ts"],"mappings":";;;;;;AAuBA;;;;;;;;;;;;;;;;;;UAAiB,gBAAA,wBAAwC,aAAA,CAAc,GAAA;EAAA,SAC5D,GAAA;EAAA,SACA,MAAA;EAAA,SACA,GAAA,GAAM,WAAA;AAAA"}