@prisma/orm-family-sql 8.0.0-rc.12-dev.15 → 8.0.0-rc.12-dev.17

package/dist/{prepared-statement-B6zvhJej-Dl488oBR.d.mts → prepared-statement-BHSj2pDk-CRzjNpcv.d.mts}

@@ -8,17 +8,17 @@ import { n as SqlQueryPlan } from "./plan-B7g2kDfQ-Bw0784x6.mjs";
 import { a as CodecValue, i as CodecTypesBase, l as RawCodecInferer, o as Expression, t as AffectedCount } from "./expression-BPoA5eEl.mjs";
 import { t as SqlExecutionPlan } from "./sql-execution-plan-Db0j752I-CI5WbdLi.mjs";
 import "./plan-DiT00Rg8.mjs";
-import { r as ExecutionContext } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
-import "./query-lane-context-CJNBt8cm.mjs";
+import { n as ExecutionContext } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
+import "./query-lane-context-BcXiJasG.mjs";
+import { h as RuntimeScope } from "./types-DFJNPLXY-vp6AGe5e.mjs";
+import "./types-BvTYXSiS.mjs";
 import { i as SqlParamRefMutator } from "./middleware-CuGBptK0-C88HCnh5.mjs";
 import "./middleware-aoqicpDI.mjs";
-import { h as RuntimeScope } from "./types-Bcujdkdw-2SDajXRo.mjs";
-import "./types-nNy0nND_.mjs";
 import { Contract, JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
-import { AfterExecuteResult, AfterQueryResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, QueryInterceptResult, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware, RuntimeMiddlewareContext } from "@prisma/orm-framework/components/runtime";
+import { AfterExecuteResult, AfterQueryResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, MutationDefaultGeneratorContributor, QueryInterceptResult, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware, RuntimeMiddlewareContext } from "@prisma/orm-framework/components/runtime";
 import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
 import { ExecutionStack, RuntimeAdapterDescriptor, RuntimeAdapterInstance, RuntimeDriverDescriptor, RuntimeDriverInstance, RuntimeExtensionDescriptor, RuntimeExtensionInstance, RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma/orm-framework/components/execution";
-//#region ../../../2-sql/5-runtime/dist/prepared-statement-B6zvhJej.d.mts
+//#region ../../../2-sql/5-runtime/dist/prepared-statement-BHSj2pDk.d.mts
 //#region src/codecs/encoding.d.ts
 interface ParamMetadata {
   readonly codec: CodecRef$1 | undefined;
@@ -273,26 +273,9 @@ type RuntimeParameterizedCodecDescriptor<P = Record<string, unknown>> = CodecDes
 /**
  * Contributor protocol for SQL components (target, adapter, extension pack). The unified `codecs:` slot returns the full {@link CodecDescriptor} list — non-parameterized and parameterized descriptors live side-by-side in the same array. The framework dispatches every codec id through the unified descriptor map without branching on parameterization.
  */
-interface SqlStaticContributions {
+interface SqlStaticContributions extends Pick<MutationDefaultGeneratorContributor, 'mutationDefaultGenerators'> {
   readonly codecs: () => ReadonlyArray<AnyCodecDescriptor>;
   readonly queryOperations?: () => SqlOperationDescriptors;
-  readonly mutationDefaultGenerators?: () => ReadonlyArray<RuntimeMutationDefaultGenerator>;
-}
-/**
- * Scope across which a generator's value is constant.
- *
- * - `'field'` — one value per defaulting site (one column, one row). Cache strategy: no cache; call per defaulting site. Right for per-row identifiers (UUIDs, CUIDs, ULIDs, nanoid, ksuid).
- * - `'row'` — one value across all defaulting sites of one row of one operation. Cache strategy: per-call cache keyed by `generatorId`. Right for correlation ids stamped into multiple columns of one row.
- * - `'query'` — one value across all rows and columns of one ORM operation. Cache strategy: caller-provided cache keyed by `generatorId`. Right for `timestampNow` (a single timestamp per bulk insert/update).
- */
-type GeneratorStability = 'field' | 'row' | 'query';
-interface RuntimeMutationDefaultGenerator {
-  readonly id: string;
-  readonly generate: (params?: Record<string, unknown>) => unknown;
-  /**
-   * Scope across which the generator's value is constant. The framework derives the cache strategy from this declaration; generator authors never need to know about cache keys. See `GeneratorStability` for the per-value semantics.
-   */
-  readonly stability: GeneratorStability;
 }
 interface SqlRuntimeTargetDescriptor<TTargetId extends string = string, TTargetInstance extends RuntimeTargetInstance<'sql', TTargetId> = RuntimeTargetInstance<'sql', TTargetId>> extends RuntimeTargetDescriptor<'sql', TTargetId, TTargetInstance>, SqlStaticContributions {}
 interface SqlRuntimeAdapterDescriptor<TTargetId extends string = string, TAdapterInstance extends RuntimeAdapterInstance<'sql', TTargetId> = SqlRuntimeAdapterInstance<TTargetId>> extends RuntimeAdapterDescriptor<'sql', TTargetId, TAdapterInstance>, SqlStaticContributions {
@@ -529,5 +512,5 @@ declare class PreparedExecutionImpl<Params> implements PreparedExecution<Params>
   execute(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
 }
 //#endregion
-export { SqlMiddleware as A, TelemetryOutcome as B, RuntimeOptions as C, RuntimeTransaction as D, RuntimeTelemetryEvent as E, SqlRuntimeDriverInstance as F, deriveParamMetadata as G, VerifyMarkerOption as H, SqlRuntimeExtensionDescriptor as I, preparedStatementQuery as J, encodeParamsWithMetadata as K, SqlRuntimeExtensionInstance as L, SqlRuntimeAdapterDescriptor as M, SqlRuntimeAdapterInstance as N, SqlExecutionStack as O, SqlRuntimeBase as P, SqlRuntimeTargetDescriptor as R, RuntimeMutationDefaultGenerator as S, RuntimeQueryable as T, createExecutionContext as U, TransactionContext as V, createSqlExecutionStack as W, withTransaction as Y, PreparedStatementInternals as _, DeclaredNullable as a, RuntimeConnection as b, ParamSpec as c, PreparedExecution as d, PreparedExecutionImpl as f, PreparedStatementImpl as g, PreparedStatementExecuteTarget as h, DeclaredCodecId as i, SqlMiddlewareContext as j, SqlExecutionStackWithDriver as k, ParamsFromDeclaration as l, PreparedStatement as m, ConnectionProvider as n, GeneratorStability as o, PreparedFor as p, preparedStatementExecute as q, Declaration as r, MarkerReader as s, BindSiteParams as t, PrepareCallback as u, PreparedStatementQueryTarget as v, RuntimeParameterizedCodecDescriptor as w, RuntimeFamilyAdapter as x, Runtime as y, SqlStaticContributions as z };
-//# sourceMappingURL=prepared-statement-B6zvhJej-Dl488oBR.d.mts.map
+export { SqlRuntimeAdapterDescriptor as A, VerifyMarkerOption as B, RuntimeQueryable as C, SqlExecutionStackWithDriver as D, SqlExecutionStack as E, SqlRuntimeExtensionInstance as F, preparedStatementExecute as G, createSqlExecutionStack as H, SqlRuntimeTargetDescriptor as I, preparedStatementQuery as K, SqlStaticContributions as L, SqlRuntimeBase as M, SqlRuntimeDriverInstance as N, SqlMiddleware as O, SqlRuntimeExtensionDescriptor as P, TelemetryOutcome as R, RuntimeParameterizedCodecDescriptor as S, RuntimeTransaction as T, deriveParamMetadata as U, createExecutionContext as V, encodeParamsWithMetadata as W, PreparedStatementQueryTarget as _, DeclaredNullable as a, RuntimeFamilyAdapter as b, ParamsFromDeclaration as c, PreparedExecutionImpl as d, PreparedFor as f, PreparedStatementInternals as g, PreparedStatementImpl as h, DeclaredCodecId as i, SqlRuntimeAdapterInstance as j, SqlMiddlewareContext as k, PrepareCallback as l, PreparedStatementExecuteTarget as m, ConnectionProvider as n, MarkerReader as o, PreparedStatement as p, withTransaction as q, Declaration as r, ParamSpec as s, BindSiteParams as t, PreparedExecution as u, Runtime as v, RuntimeTelemetryEvent as w, RuntimeOptions as x, RuntimeConnection as y, TransactionContext as z };
+//# sourceMappingURL=prepared-statement-BHSj2pDk-CRzjNpcv.d.mts.map

package/dist/prepared-statement-BHSj2pDk-CRzjNpcv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepared-statement-BHSj2pDk-CRzjNpcv.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/prepared-statement-BHSj2pDk.d.mts"],"mappings":"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"}

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

@@ -0,0 +1 @@
+import "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";

package/dist/{query-lane-context-Bi1GUXHp-Bo4OTjhW.d.mts → query-lane-context-D6o9YrEV-bouFPM6u.d.mts}

@@ -3,9 +3,10 @@ import "./types-C36_3E6_.mjs";
 import { a as SqlOperationRegistry } from "./index-Cef8iy1o.mjs";
 import { c as AnyExpression, k as ContractCodecRegistry } from "./types-Yui2yFf6-TP-oRDTX.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
+import { MutationDefaults } from "@prisma/orm-framework/components/runtime";
 import { CodecDescriptor, CodecRef } from "@prisma/orm-framework/components/codec";
 import { AggregateDescriptor, AggregateResultNullability } from "@prisma/orm-framework/components/components";
-//#region ../../../2-sql/4-lanes/relational-core/dist/query-lane-context-Bi1GUXHp.d.mts
+//#region ../../../2-sql/4-lanes/relational-core/dist/query-lane-context-D6o9YrEV.d.mts
 //#region src/aggregate-descriptor.d.ts
 /**
  * What a lowering hook is handed: the expression being aggregated (absent for operations that consume no value) and the codec of that expression.
@@ -94,35 +95,12 @@ interface SqlAggregateDescriptorRegistry {
  * 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;
-  /**
-   * Namespace of the target table. Execution-default refs are namespace-scoped,
-   * so only defaults declared for `(namespace, table)` are applied — this is what
-   * disambiguates same-named tables across namespaces. Required so the coordinate
-   * is always part of the match; a missing namespace is a caller bug, not a
-   * silent degrade to table-name-only matching.
-   */
-  readonly namespace: 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>> {
+interface ExecutionContext<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> extends MutationDefaults {
   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. Runtime dispatch (`encodeParam` / `decodeRow`) resolves codecs via `forCodecRef(ref)` — the single dispatch shape for AST-bound codec resolution.
@@ -141,11 +119,7 @@ interface ExecutionContext<TContract extends Contract<SqlStorage> = Contract<Sql
    * 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, SqlAggregateDescriptorRegistry as c, TypeHelperRegistry as d, isSqlAggregateDescriptor as f, MutationDefaultsOp as i, SqlAggregateLowering as l, CodecDescriptorRegistry as n, ResolvedSqlAggregate as o, ExecutionContext as r, SqlAggregateDescriptor as s, AppliedMutationDefault as t, SqlAggregateLoweringContext as u };
-//# sourceMappingURL=query-lane-context-Bi1GUXHp-Bo4OTjhW.d.mts.map
+export { SqlAggregateDescriptorRegistry as a, TypeHelperRegistry as c, SqlAggregateDescriptor as i, isSqlAggregateDescriptor as l, ExecutionContext as n, SqlAggregateLowering as o, ResolvedSqlAggregate as r, SqlAggregateLoweringContext as s, CodecDescriptorRegistry as t };
+//# sourceMappingURL=query-lane-context-D6o9YrEV-bouFPM6u.d.mts.map

package/dist/query-lane-context-D6o9YrEV-bouFPM6u.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-lane-context-D6o9YrEV-bouFPM6u.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/query-lane-context-D6o9YrEV.d.mts"],"mappings":";;;;;;;;;;;;;UAWU;WACC,MAAM;WACN,YAAY;;;;;;;KAOlB,wBAAwB,SAAS,gCAAgC;;;;;;;;KAQjE,yBAAyB;WACnB,QAAQ;;;iBAGF,yBAAyB,iBAAiB,SAAS;;;;;;UAM1D;;;;EAIR,cAAc,kBAAkB;;;;;;;;;;;;;;EAchC,kBAAkB,qBAAqB,eAAe,iBAAiB;;;;EAIvE,UAAU,iBAAiB;;;;EAI3B,aAAa,8BAA8B;;;;;;;KAOxC,uBAAuB;WACjB;WACA,QAAQ;WACR,OAAO;;;;;;;UAOR;;;;;;EAMR,QAAQ,mBAAmB,QAAQ,WAAW;;EAE9C,UAAU,iBAAiB;;;;;KAKxB,qBAAqB;;;;;;UAMhB,iBAAiB,kBAAkB,SAAS,cAAc,SAAS,qBAAqB;WACvF,UAAU;;;;WAIV,gBAAgB;;;;WAIhB,kBAAkB;;;;WAIlB,sBAAsB;WACtB,iBAAiB;;;;WAIjB,OAAO"}

package/dist/relational-core.d.mts

@@ -6,8 +6,8 @@ import { n as SqlQueryPlan, r as planFromAst, t as Preparable } from "./plan-B7g
 import { C as buildOperation, D as param, E as isExpression, O as toExpr, S as TraitExpression, T as createRawSql, _ as RawSqlStatementBuilder, a as CodecValue, b as ScalarListExpression, c as RawAffectedCountQuery, d as RawRow, f as RawRowQuery, g as RawSqlInterpolation, h as RawSqlBuilder, i as CodecTypesBase, l as RawCodecInferer, m as RawRowSpecEntry, n as BuildOperationSpec, o as Expression, p as RawRowSpec, r as CodecExpression, s as NoReservedRowColumn, t as AffectedCount, u as RawPlanContext, v as RawSqlStatementTag, w as codecOf, x as ScopeField, y as RawSqlTag } from "./expression-BPoA5eEl.mjs";
 import { t as SqlExecutionPlan } from "./sql-execution-plan-Db0j752I-CI5WbdLi.mjs";
 import "./plan-DiT00Rg8.mjs";
-import { a as MutationDefaultsOptions, c as SqlAggregateDescriptorRegistry, d as TypeHelperRegistry, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as ResolvedSqlAggregate, r as ExecutionContext, t as AppliedMutationDefault } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
-import "./query-lane-context-CJNBt8cm.mjs";
+import { a as SqlAggregateDescriptorRegistry, c as TypeHelperRegistry, n as ExecutionContext, r as ResolvedSqlAggregate, t as CodecDescriptorRegistry } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
+import "./query-lane-context-BcXiJasG.mjs";
+import { S as TablesOf, _ as SqlOrmPlan, a as ColumnsOf, b as TableKey, c as META, d as ModelMetadata, f as OperationTypeSignature, g as SqlBuilderOptions, h as RuntimeScope, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as SqlPlan, x as TableMetadata, y as TableDef } from "./types-DFJNPLXY-vp6AGe5e.mjs";
 import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-CuGBptK0-C88HCnh5.mjs";
-import { S as TablesOf, _ as SqlOrmPlan, a as ColumnsOf, b as TableKey, c as META, d as ModelMetadata, f as OperationTypeSignature, g as SqlBuilderOptions, h as RuntimeScope, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as SqlPlan, x as TableMetadata, y as TableDef } from "./types-Bcujdkdw-2SDajXRo.mjs";
-export { Adapter, AdapterProfile, AdapterTarget, AffectedCount, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyCodecDescriptorTemplate, AnyDdlColumnDefault, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyJsonValueProjection, AnyOperationArg, AnyParamRef, AnyQueryAst, AppliedMutationDefault, AstRewriter, BinaryExpr, BinaryOp, BuildOperationSpec, BuildOptions, BuildParamsMap, CaseBranch, CaseExpr, CastExpr, CheckExpressionConstraint, Codec$1 as Codec, type CodecCallContext$1 as CodecCallContext, type CodecDescriptor$1 as CodecDescriptor, CodecDescriptorRegistry, CodecExpression, CodecJsonValueProjection, type CodecRef$1 as CodecRef, type CodecTrait$1 as CodecTrait, CodecTypes, CodecTypesBase, CodecValue, ColumnRef, ColumnResolutionContract, ColumnsOf, ComputeColumnJsType, ContractCodecRegistry, DdlColumn, DdlColumnDefault, DdlColumnDefaultVisitor, DdlColumnRenderContext, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecJson, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, Expression, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, FunctionSourceAlias, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, IntegerStep, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectEntry, JsonObjectExpr, JsonValueProjectionVisitor, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralExpr, LoweredParam, LoweredStatement, Lowerer, LowererContext, META, MarkerReadResult, Meta, ModelDef, ModelMetadata, MutationDefaultsOp, MutationDefaultsOptions, NativeJsonValueProjection, NoReservedRowColumn, NotExpr, NullCheckExpr, NumberClassification, NumberClassifierSpec, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderByItem, OrderByNulls, ParamRef, type ParamRefEntry, type ParamRefEntryUnion, type ParamRefHandle, Preparable, PreparedExecuteRequest, PreparedParamRef, PreparedStatementHandle, PrimaryKeyConstraint, ProjectionExpr, ProjectionItem, RawAffectedCountQuery, RawCodecInferer, RawExpr, RawPlanContext, RawQueryAst, RawQueryColumn, RawQueryResult, RawRow, RawRowQuery, RawRowSpec, RawRowSpecEntry, RawSqlBuilder, RawSqlInterpolation, RawSqlLiteral, RawSqlStatementBuilder, RawSqlStatementTag, RawSqlTag, ResolvedSqlAggregate, type RuntimeScope, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_VARCHAR_CODEC_ID, ScalarListExpression, ScopeField, SelectAst, SelectAstOptions, SqlAggregateDescriptorRegistry, SqlBuilderOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, type SqlExecutionPlan, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, type SqlOrmPlan, type SqlParamRefMutator, type SqlParamRefMutatorInternal, SqlPlan, SqlQueryPlan, SqlQueryable, SqlStatementStats, SqlTextCodec, SqlTextDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TraitExpression, TypeHelperRegistry, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, aggregateFnNames, buildOperation, canonicalNumeralText, codecOf, collectOrderedParamRefs, compact, createNumberClassifier, createRawSql, createSqlParamRefMutator, escapePslString, frozenCodecRef, isAggregateFn, isDdlNode, isExpression, isNonFiniteText, isNumeralText, isOrderByDirection, isOrderByNulls, isQueryAst, isWhereExpr, numeralText, param, parseJsonBody, planFromAst, printJsonBody, queryAstKinds, signedRange, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDecodeJson, sqlFloatDescriptor, sqlFloatEncode, sqlFloatEncodeJson, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds };
+export { Adapter, AdapterProfile, AdapterTarget, AffectedCount, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyCodecDescriptorTemplate, AnyDdlColumnDefault, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyJsonValueProjection, AnyOperationArg, AnyParamRef, AnyQueryAst, AstRewriter, BinaryExpr, BinaryOp, BuildOperationSpec, BuildOptions, BuildParamsMap, CaseBranch, CaseExpr, CastExpr, CheckExpressionConstraint, Codec$1 as Codec, type CodecCallContext$1 as CodecCallContext, type CodecDescriptor$1 as CodecDescriptor, CodecDescriptorRegistry, CodecExpression, CodecJsonValueProjection, type CodecRef$1 as CodecRef, type CodecTrait$1 as CodecTrait, CodecTypes, CodecTypesBase, CodecValue, ColumnRef, ColumnResolutionContract, ColumnsOf, ComputeColumnJsType, ContractCodecRegistry, DdlColumn, DdlColumnDefault, DdlColumnDefaultVisitor, DdlColumnRenderContext, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecJson, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, Expression, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, FunctionSourceAlias, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, IntegerStep, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectEntry, JsonObjectExpr, JsonValueProjectionVisitor, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralExpr, LoweredParam, LoweredStatement, Lowerer, LowererContext, META, MarkerReadResult, Meta, ModelDef, ModelMetadata, NativeJsonValueProjection, NoReservedRowColumn, NotExpr, NullCheckExpr, NumberClassification, NumberClassifierSpec, OperationExpr, OperationTypeSignature, OperationTypes, OperationsForTypeId, OrExpr, OrderByItem, OrderByNulls, ParamRef, type ParamRefEntry, type ParamRefEntryUnion, type ParamRefHandle, Preparable, PreparedExecuteRequest, PreparedParamRef, PreparedStatementHandle, PrimaryKeyConstraint, ProjectionExpr, ProjectionItem, RawAffectedCountQuery, RawCodecInferer, RawExpr, RawPlanContext, RawQueryAst, RawQueryColumn, RawQueryResult, RawRow, RawRowQuery, RawRowSpec, RawRowSpecEntry, RawSqlBuilder, RawSqlInterpolation, RawSqlLiteral, RawSqlStatementBuilder, RawSqlStatementTag, RawSqlTag, ResolvedSqlAggregate, type RuntimeScope, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_VARCHAR_CODEC_ID, ScalarListExpression, ScopeField, SelectAst, SelectAstOptions, SqlAggregateDescriptorRegistry, SqlBuilderOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, type SqlExecutionPlan, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, type SqlOrmPlan, type SqlParamRefMutator, type SqlParamRefMutatorInternal, SqlPlan, SqlQueryPlan, SqlQueryable, SqlStatementStats, SqlTextCodec, SqlTextDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TraitExpression, TypeHelperRegistry, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, aggregateFnNames, buildOperation, canonicalNumeralText, codecOf, collectOrderedParamRefs, compact, createNumberClassifier, createRawSql, createSqlParamRefMutator, escapePslString, frozenCodecRef, isAggregateFn, isDdlNode, isExpression, isNonFiniteText, isNumeralText, isOrderByDirection, isOrderByNulls, isQueryAst, isWhereExpr, numeralText, param, parseJsonBody, planFromAst, printJsonBody, queryAstKinds, signedRange, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDecodeJson, sqlFloatDescriptor, sqlFloatEncode, sqlFloatEncodeJson, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds };

package/dist/relational-core__aggregate-descriptor-registry.d.mts

@@ -1,4 +1,4 @@
-import { c as SqlAggregateDescriptorRegistry, f as isSqlAggregateDescriptor, l as SqlAggregateLowering, n as CodecDescriptorRegistry, s as SqlAggregateDescriptor, u as SqlAggregateLoweringContext } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
+import { a as SqlAggregateDescriptorRegistry, i as SqlAggregateDescriptor, l as isSqlAggregateDescriptor, o as SqlAggregateLowering, s as SqlAggregateLoweringContext, t as CodecDescriptorRegistry } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
 //#region ../../../2-sql/4-lanes/relational-core/dist/exports/aggregate-descriptor-registry.d.mts
 //#region src/aggregate-descriptor-registry.d.ts
 /**

package/dist/relational-core__codec-descriptor-registry.d.mts

@@ -1,7 +1,7 @@
 import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import "./types-C36_3E6_.mjs";
 import { o as AnyCodecDescriptor$1 } from "./types-Yui2yFf6-TP-oRDTX.mjs";
-import { n as CodecDescriptorRegistry } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
+import { t as CodecDescriptorRegistry } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
 import { CodecRef } from "@prisma/orm-framework/components/codec";
 //#region ../../../2-sql/4-lanes/relational-core/dist/exports/codec-descriptor-registry.d.mts
 //#region src/codec-descriptor-registry.d.ts

package/dist/relational-core__query-lane-context.d.mts

@@ -1,3 +1,3 @@
-import { a as MutationDefaultsOptions, c as SqlAggregateDescriptorRegistry, d as TypeHelperRegistry, i as MutationDefaultsOp, n as CodecDescriptorRegistry, o as ResolvedSqlAggregate, r as ExecutionContext, t as AppliedMutationDefault } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
-import "./query-lane-context-CJNBt8cm.mjs";
-export { AppliedMutationDefault, CodecDescriptorRegistry, ExecutionContext, MutationDefaultsOp, MutationDefaultsOptions, ResolvedSqlAggregate, SqlAggregateDescriptorRegistry, TypeHelperRegistry };
+import { a as SqlAggregateDescriptorRegistry, c as TypeHelperRegistry, n as ExecutionContext, r as ResolvedSqlAggregate, t as CodecDescriptorRegistry } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
+import "./query-lane-context-BcXiJasG.mjs";
+export { CodecDescriptorRegistry, ExecutionContext, ResolvedSqlAggregate, SqlAggregateDescriptorRegistry, TypeHelperRegistry };

package/dist/relational-core__types.d.mts

@@ -1,3 +1,3 @@
-import { S as TablesOf, _ as SqlOrmPlan, a as ColumnsOf, b as TableKey, c as META, d as ModelMetadata, f as OperationTypeSignature, g as SqlBuilderOptions, h as RuntimeScope, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as SqlPlan, x as TableMetadata, y as TableDef } from "./types-Bcujdkdw-2SDajXRo.mjs";
-import "./types-nNy0nND_.mjs";
+import { S as TablesOf, _ as SqlOrmPlan, a as ColumnsOf, b as TableKey, c as META, d as ModelMetadata, f as OperationTypeSignature, g as SqlBuilderOptions, h as RuntimeScope, i as ColumnResolutionContract, l as Meta, m as OperationsForTypeId, n as BuildParamsMap, o as ComputeColumnJsType, p as OperationTypes, r as CodecTypes, s as Expr, t as BuildOptions, u as ModelDef, v as SqlPlan, x as TableMetadata, y as TableDef } from "./types-DFJNPLXY-vp6AGe5e.mjs";
+import "./types-BvTYXSiS.mjs";
 export { BuildOptions, BuildParamsMap, CodecTypes, ColumnResolutionContract, ColumnsOf, ComputeColumnJsType, Expr, META, Meta, ModelDef, ModelMetadata, OperationTypeSignature, OperationTypes, OperationsForTypeId, type RuntimeScope, SqlBuilderOptions, type SqlOrmPlan, SqlPlan, TableDef, TableKey, TableMetadata, TablesOf };

package/dist/{runtime-DYpzLADy.d.mts → runtime-DgOeosYa.d.mts}

@@ -1,7 +1,6 @@
 import "./resolve-storage-table-Nyrgk4h8.mjs";
-import { S as RuntimeMutationDefaultGenerator } from "./prepared-statement-B6zvhJej-Dl488oBR.mjs";
-import "./index-C10GDLBQ.mjs";
 import { ResolvedDomainModel, UNBOUND_DOMAIN_NAMESPACE_ID, resolveDomainModel } from "@prisma/orm-framework/contract/types";
+import { RuntimeMutationDefaultGenerator } from "@prisma/orm-framework/components/runtime";
 import { RuntimeFamilyDescriptor, RuntimeFamilyInstance } from "@prisma/orm-framework/components/execution";
 //#region ../../../2-sql/9-family/dist/runtime.d.mts
 //#region src/core/runtime-instance.d.ts
@@ -37,11 +36,11 @@ declare const sqlRuntimeFamilyDescriptor: RuntimeFamilyDescriptor<'sql', SqlRunt
  * every timestamp-defaulted column. Matches Prisma 6's `@updatedAt`
  * semantics: one `new Date()` per lowered mutation, not per row.
  *
- * Lives in a runtime-plane-only module so the control-plane
- * `timestamp-now-generator.ts` (descriptor + authoring presets) stays
- * free of `@internal/sql-runtime` imports.
+ * Lives in its own module, exported only through `exports/runtime.ts`,
+ * so the control-plane `timestamp-now-generator.ts` (descriptor +
+ * authoring presets) stays free of runtime-plane imports.
  */
 declare function timestampNowRuntimeGenerator(): RuntimeMutationDefaultGenerator;
 //#endregion
 export { timestampNowRuntimeGenerator as a, sqlRuntimeFamilyDescriptor as i, UNBOUND_DOMAIN_NAMESPACE_ID as n, resolveDomainModel as r, ResolvedDomainModel as t };
-//# sourceMappingURL=runtime-DYpzLADy.d.mts.map
+//# sourceMappingURL=runtime-DgOeosYa.d.mts.map

package/dist/runtime-DgOeosYa.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-DgOeosYa.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/runtime.d.mts"],"mappings":";;;;;;;;;;;;;;UAaU,iCAAiC;;;;;;;;;;;cAW7B,4BAA4B,+BAA+B;;;;;;;;;;;;;;;;;iBAiBxD,gCAAgC"}

package/dist/{runtime-DzmRvRj_.mjs → runtime-Z3nD7ix1.mjs}

@@ -37,9 +37,9 @@ Object.freeze(sqlRuntimeFamilyDescriptor);
 * every timestamp-defaulted column. Matches Prisma 6's `@updatedAt`
 * semantics: one `new Date()` per lowered mutation, not per row.
 *
-* Lives in a runtime-plane-only module so the control-plane
-* `timestamp-now-generator.ts` (descriptor + authoring presets) stays
-* free of `@internal/sql-runtime` imports.
+* Lives in its own module, exported only through `exports/runtime.ts`,
+* so the control-plane `timestamp-now-generator.ts` (descriptor +
+* authoring presets) stays free of runtime-plane imports.
 */
 function timestampNowRuntimeGenerator() {
 	return {
@@ -52,4 +52,4 @@ var runtime_default = sqlRuntimeFamilyDescriptor;
 //#endregion
 export { timestampNowRuntimeGenerator as i, resolveDomainModel as n, runtime_default as r, UNBOUND_DOMAIN_NAMESPACE_ID as t };
 
-//# sourceMappingURL=runtime-DzmRvRj_.mjs.map
+//# sourceMappingURL=runtime-Z3nD7ix1.mjs.map

package/dist/{runtime-DzmRvRj_.mjs.map → runtime-Z3nD7ix1.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"runtime-DzmRvRj_.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/runtime.mjs"],"sourcesContent":["import { TIMESTAMP_NOW_GENERATOR_ID } from \"@internal/framework-components/authoring\";\nimport { UNBOUND_DOMAIN_NAMESPACE_ID, resolveDomainModel } from \"@internal/contract/types\";\nimport { resolveStorageTable } from \"@internal/sql-contract/resolve-storage-table\";\n//#region src/core/runtime-instance.ts\n/**\n* Creates a SQL execution-plane family instance.\n*\n* This will be renamed to `createSqlExecutionFamilyInstance()` as part of `TML-1842`.\n*/\nfunction createSqlRuntimeFamilyInstance() {\n\treturn { familyId: \"sql\" };\n}\n//#endregion\n//#region src/core/runtime-descriptor.ts\n/**\n* SQL execution-plane family descriptor.\n*\n* Note: this is currently named `sqlRuntimeFamilyDescriptor` because the execution plane\n* framework types are still using the `Runtime*` naming (`RuntimeFamilyDescriptor`, etc.).\n*\n* This will be renamed to `sqlExecutionFamilyDescriptor` as part of `TML-1842`.\n*/\nconst sqlRuntimeFamilyDescriptor = {\n\tkind: \"family\",\n\tid: \"sql\",\n\tfamilyId: \"sql\",\n\tversion: \"0.0.1\",\n\tcreate() {\n\t\treturn createSqlRuntimeFamilyInstance();\n\t}\n};\nObject.freeze(sqlRuntimeFamilyDescriptor);\n//#endregion\n//#region src/core/timestamp-now-runtime-generator.ts\n/**\n* Builds the canonical runtime-plane generator for the wall-clock-now\n* mutation default. Returns `new Date()`; semantics are target-agnostic\n* so all SQL targets share this single implementation.\n*\n* Declares `stability: 'query'` so a single ORM bulk operation\n* (e.g. `createAll([...])`) shares one timestamp across every row and\n* every timestamp-defaulted column. Matches Prisma 6's `@updatedAt`\n* semantics: one `new Date()` per lowered mutation, not per row.\n*\n* Lives in a runtime-plane-only module so the control-plane\n* `timestamp-now-generator.ts` (descriptor + authoring presets) stays\n* free of `@internal/sql-runtime` imports.\n*/\nfunction timestampNowRuntimeGenerator() {\n\treturn {\n\t\tid: TIMESTAMP_NOW_GENERATOR_ID,\n\t\tgenerate: () => /* @__PURE__ */ new Date(),\n\t\tstability: \"query\"\n\t};\n}\n//#endregion\n//#region src/exports/runtime.ts\nvar runtime_default = sqlRuntimeFamilyDescriptor;\n//#endregion\nexport { UNBOUND_DOMAIN_NAMESPACE_ID, runtime_default as default, resolveDomainModel, resolveStorageTable, timestampNowRuntimeGenerator };\n\n//# sourceMappingURL=runtime.mjs.map"],"mappings":";;;;;;;;AASA,SAAS,iCAAiC;CACzC,OAAO,EAAE,UAAU,MAAM;AAC1B;;;;;;;;;AAWA,MAAM,6BAA6B;CAClC,MAAM;CACN,IAAI;CACJ,UAAU;CACV,SAAS;CACT,SAAS;EACR,OAAO,+BAA+B;CACvC;AACD;AACA,OAAO,OAAO,0BAA0B;;;;;;;;;;;;;;;AAiBxC,SAAS,+BAA+B;CACvC,OAAO;EACN,IAAI;EACJ,gCAAgC,IAAI,KAAK;EACzC,WAAW;CACZ;AACD;AAGA,IAAI,kBAAkB"}
+{"version":3,"file":"runtime-Z3nD7ix1.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/runtime.mjs"],"sourcesContent":["import { TIMESTAMP_NOW_GENERATOR_ID } from \"@internal/framework-components/authoring\";\nimport { UNBOUND_DOMAIN_NAMESPACE_ID, resolveDomainModel } from \"@internal/contract/types\";\nimport { resolveStorageTable } from \"@internal/sql-contract/resolve-storage-table\";\n//#region src/core/runtime-instance.ts\n/**\n* Creates a SQL execution-plane family instance.\n*\n* This will be renamed to `createSqlExecutionFamilyInstance()` as part of `TML-1842`.\n*/\nfunction createSqlRuntimeFamilyInstance() {\n\treturn { familyId: \"sql\" };\n}\n//#endregion\n//#region src/core/runtime-descriptor.ts\n/**\n* SQL execution-plane family descriptor.\n*\n* Note: this is currently named `sqlRuntimeFamilyDescriptor` because the execution plane\n* framework types are still using the `Runtime*` naming (`RuntimeFamilyDescriptor`, etc.).\n*\n* This will be renamed to `sqlExecutionFamilyDescriptor` as part of `TML-1842`.\n*/\nconst sqlRuntimeFamilyDescriptor = {\n\tkind: \"family\",\n\tid: \"sql\",\n\tfamilyId: \"sql\",\n\tversion: \"0.0.1\",\n\tcreate() {\n\t\treturn createSqlRuntimeFamilyInstance();\n\t}\n};\nObject.freeze(sqlRuntimeFamilyDescriptor);\n//#endregion\n//#region src/core/timestamp-now-runtime-generator.ts\n/**\n* Builds the canonical runtime-plane generator for the wall-clock-now\n* mutation default. Returns `new Date()`; semantics are target-agnostic\n* so all SQL targets share this single implementation.\n*\n* Declares `stability: 'query'` so a single ORM bulk operation\n* (e.g. `createAll([...])`) shares one timestamp across every row and\n* every timestamp-defaulted column. Matches Prisma 6's `@updatedAt`\n* semantics: one `new Date()` per lowered mutation, not per row.\n*\n* Lives in its own module, exported only through `exports/runtime.ts`,\n* so the control-plane `timestamp-now-generator.ts` (descriptor +\n* authoring presets) stays free of runtime-plane imports.\n*/\nfunction timestampNowRuntimeGenerator() {\n\treturn {\n\t\tid: TIMESTAMP_NOW_GENERATOR_ID,\n\t\tgenerate: () => /* @__PURE__ */ new Date(),\n\t\tstability: \"query\"\n\t};\n}\n//#endregion\n//#region src/exports/runtime.ts\nvar runtime_default = sqlRuntimeFamilyDescriptor;\n//#endregion\nexport { UNBOUND_DOMAIN_NAMESPACE_ID, runtime_default as default, resolveDomainModel, resolveStorageTable, timestampNowRuntimeGenerator };\n\n//# sourceMappingURL=runtime.mjs.map"],"mappings":";;;;;;;;AASA,SAAS,iCAAiC;CACzC,OAAO,EAAE,UAAU,MAAM;AAC1B;;;;;;;;;AAWA,MAAM,6BAA6B;CAClC,MAAM;CACN,IAAI;CACJ,UAAU;CACV,SAAS;CACT,SAAS;EACR,OAAO,+BAA+B;CACvC;AACD;AACA,OAAO,OAAO,0BAA0B;;;;;;;;;;;;;;;AAiBxC,SAAS,+BAA+B;CACvC,OAAO;EACN,IAAI;EACJ,gCAAgC,IAAI,KAAK;EACzC,WAAW;CACZ;AACD;AAGA,IAAI,kBAAkB"}

package/dist/runtime.d.mts

@@ -1,5 +1,5 @@
 import { s as MarkerReadResult } from "./ast-B9jF6tRJ.mjs";
-import { d as TypeHelperRegistry, r as ExecutionContext } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
-import { A as SqlMiddleware, B as TelemetryOutcome, C as RuntimeOptions, D as RuntimeTransaction, E as RuntimeTelemetryEvent, F as SqlRuntimeDriverInstance, G as deriveParamMetadata, H as VerifyMarkerOption, I as SqlRuntimeExtensionDescriptor, K as encodeParamsWithMetadata, L as SqlRuntimeExtensionInstance, M as SqlRuntimeAdapterDescriptor, N as SqlRuntimeAdapterInstance, O as SqlExecutionStack, P as SqlRuntimeBase, R as SqlRuntimeTargetDescriptor, S as RuntimeMutationDefaultGenerator, T as RuntimeQueryable, U as createExecutionContext, V as TransactionContext, W as createSqlExecutionStack, Y as withTransaction, _ as PreparedStatementInternals, a as DeclaredNullable, b as RuntimeConnection, c as ParamSpec, d as PreparedExecution, f as PreparedExecutionImpl, g as PreparedStatementImpl, i as DeclaredCodecId, j as SqlMiddlewareContext, k as SqlExecutionStackWithDriver, l as ParamsFromDeclaration, m as PreparedStatement, n as ConnectionProvider, o as GeneratorStability, p as PreparedFor, r as Declaration, s as MarkerReader, t as BindSiteParams, u as PrepareCallback, w as RuntimeParameterizedCodecDescriptor, x as RuntimeFamilyAdapter, y as Runtime, z as SqlStaticContributions } from "./prepared-statement-B6zvhJej-Dl488oBR.mjs";
-import { a as LintsOptions, c as budgets, d as lints, f as lowerSqlPlan, i as ExecuteInterceptResult, l as createAstCodecRegistry, m as validateContractCodecMappings, n as AfterQueryResult, o as Log, p as validateCodecRegistryCompleteness, r as BudgetsOptions, s as QueryInterceptResult, t as AfterExecuteResult, u as extractCodecIds } from "./index-C10GDLBQ.mjs";
-export { type AfterExecuteResult, type AfterQueryResult, type BindSiteParams, type BudgetsOptions, type ConnectionProvider, type Declaration, type DeclaredCodecId, type DeclaredNullable, type ExecuteInterceptResult, type ExecutionContext, type GeneratorStability, type LintsOptions, type Log, type MarkerReadResult, type MarkerReader, type ParamSpec, type ParamsFromDeclaration, type PrepareCallback, type PreparedExecution, PreparedExecutionImpl, type PreparedFor, type PreparedStatement, PreparedStatementImpl, type PreparedStatementInternals, type QueryInterceptResult, type Runtime, type RuntimeConnection, type RuntimeFamilyAdapter, type RuntimeMutationDefaultGenerator, type RuntimeOptions, type RuntimeParameterizedCodecDescriptor, type RuntimeQueryable, type RuntimeTelemetryEvent, type RuntimeTransaction, type SqlExecutionStack, type SqlExecutionStackWithDriver, type SqlMiddleware, type SqlMiddlewareContext, type SqlRuntimeAdapterDescriptor, type SqlRuntimeAdapterInstance, SqlRuntimeBase, type SqlRuntimeDriverInstance, type SqlRuntimeExtensionDescriptor, type SqlRuntimeExtensionInstance, type SqlRuntimeTargetDescriptor, type SqlStaticContributions, type TelemetryOutcome, type TransactionContext, type TypeHelperRegistry, type VerifyMarkerOption, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, lints, lowerSqlPlan, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };
+import { c as TypeHelperRegistry, n as ExecutionContext } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
+import { A as SqlRuntimeAdapterDescriptor, B as VerifyMarkerOption, C as RuntimeQueryable, D as SqlExecutionStackWithDriver, E as SqlExecutionStack, F as SqlRuntimeExtensionInstance, H as createSqlExecutionStack, I as SqlRuntimeTargetDescriptor, L as SqlStaticContributions, M as SqlRuntimeBase, N as SqlRuntimeDriverInstance, O as SqlMiddleware, P as SqlRuntimeExtensionDescriptor, R as TelemetryOutcome, S as RuntimeParameterizedCodecDescriptor, T as RuntimeTransaction, U as deriveParamMetadata, V as createExecutionContext, W as encodeParamsWithMetadata, a as DeclaredNullable, b as RuntimeFamilyAdapter, c as ParamsFromDeclaration, d as PreparedExecutionImpl, f as PreparedFor, g as PreparedStatementInternals, h as PreparedStatementImpl, i as DeclaredCodecId, j as SqlRuntimeAdapterInstance, k as SqlMiddlewareContext, l as PrepareCallback, n as ConnectionProvider, o as MarkerReader, p as PreparedStatement, q as withTransaction, r as Declaration, s as ParamSpec, t as BindSiteParams, u as PreparedExecution, v as Runtime, w as RuntimeTelemetryEvent, x as RuntimeOptions, y as RuntimeConnection, z as TransactionContext } from "./prepared-statement-BHSj2pDk-CRzjNpcv.mjs";
+import { a as LintsOptions, c as budgets, d as lints, f as lowerSqlPlan, i as ExecuteInterceptResult, l as createAstCodecRegistry, m as validateContractCodecMappings, n as AfterQueryResult, o as Log, p as validateCodecRegistryCompleteness, r as BudgetsOptions, s as QueryInterceptResult, t as AfterExecuteResult, u as extractCodecIds } from "./index-B-CraAhf.mjs";
+export { type AfterExecuteResult, type AfterQueryResult, type BindSiteParams, type BudgetsOptions, type ConnectionProvider, type Declaration, type DeclaredCodecId, type DeclaredNullable, type ExecuteInterceptResult, type ExecutionContext, type LintsOptions, type Log, type MarkerReadResult, type MarkerReader, type ParamSpec, type ParamsFromDeclaration, type PrepareCallback, type PreparedExecution, PreparedExecutionImpl, type PreparedFor, type PreparedStatement, PreparedStatementImpl, type PreparedStatementInternals, type QueryInterceptResult, type Runtime, type RuntimeConnection, type RuntimeFamilyAdapter, type RuntimeOptions, type RuntimeParameterizedCodecDescriptor, type RuntimeQueryable, type RuntimeTelemetryEvent, type RuntimeTransaction, type SqlExecutionStack, type SqlExecutionStackWithDriver, type SqlMiddleware, type SqlMiddlewareContext, type SqlRuntimeAdapterDescriptor, type SqlRuntimeAdapterInstance, SqlRuntimeBase, type SqlRuntimeDriverInstance, type SqlRuntimeExtensionDescriptor, type SqlRuntimeExtensionInstance, type SqlRuntimeTargetDescriptor, type SqlStaticContributions, type TelemetryOutcome, type TransactionContext, type TypeHelperRegistry, type VerifyMarkerOption, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, lints, lowerSqlPlan, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };

package/dist/runtime.mjs

@@ -9,7 +9,7 @@ import { isStructuredError } from "@prisma/orm-framework/utils/structured-error"
 import { createHash } from "node:crypto";
 import { assertNever } from "@prisma/orm-framework/utils/internal-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatibility, raceAgainstAbort, runBeforeExecuteChain, runBeforeQueryChain, runExecuteWithMiddleware, runQueryWithMiddleware, runtimeError } from "@prisma/orm-framework/components/runtime";
+import { AsyncIterableResult, RuntimeCore, applyMutationDefaults, assertMutationDefaultGeneratorsAvailable, checkAborted, checkMiddlewareCompatibility, collectMutationDefaultGenerators, raceAgainstAbort, runBeforeExecuteChain, runBeforeQueryChain, runExecuteWithMiddleware, runQueryWithMiddleware, runtimeError } from "@prisma/orm-framework/components/runtime";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
 import { materializeCodec, resolveCodecDescriptorOrThrow } from "@prisma/orm-framework/components/codec";
@@ -17,7 +17,7 @@ import { checkContractComponentRequirements, mergeCapabilityMatrices } from "@pr
 import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
 import { createExecutionStack } from "@prisma/orm-framework/components/execution";
 import { hashContent } from "@prisma/orm-framework/utils/hash-content";
-//#region ../../../2-sql/5-runtime/dist/exports-cGWDoah9.mjs
+//#region ../../../2-sql/5-runtime/dist/exports-CCSITeUw.mjs
 /**
 * Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
 *
@@ -557,7 +557,7 @@ function validateTypeParams(typeParams, descriptor, context) {
 			typeParams
 		});
 	}
-	return result.value;
+	return blindCast(result.value);
 }
 /**
 * Collect every {@link CodecDescriptor} contributed by the SQL stack and partition into "parameterized" vs "non-parameterized" via the descriptor's own {@link CodecDescriptorImpl.isParameterized} getter: a descriptor is parameterized when it has a `paramsSchema`.
@@ -572,7 +572,7 @@ function collectCodecDescriptors(contributors) {
 		if (seen.has(descriptor.codecId)) throw runtimeError("RUNTIME.DUPLICATE_CODEC", `Duplicate codec descriptor for codecId '${descriptor.codecId}'.`, { codecId: descriptor.codecId });
 		seen.add(descriptor.codecId);
 		all.push(descriptor);
-		if (descriptor.isParameterized) parameterized.set(descriptor.codecId, descriptor);
+		if (descriptor.isParameterized) parameterized.set(descriptor.codecId, blindCast(descriptor));
 	}
 	return {
 		all,
@@ -705,7 +705,7 @@ function buildContractCodecRegistry(contract, codecDescriptors) {
 		const instanceTypeParams = typeInstance.typeParams;
 		const key = refKeyOf(instanceTypeParams !== void 0 && Object.keys(instanceTypeParams).length > 0 ? {
 			codecId: typeInstance.codecId,
-			typeParams: instanceTypeParams
+			typeParams: blindCast(instanceTypeParams)
 		} : { codecId: typeInstance.codecId });
 		const sites = typeRefSites.get(typeName) ?? [];
 		const existing = usedAtByKey.get(key);
@@ -754,84 +754,6 @@ function buildContractCodecRegistry(contract, codecDescriptors) {
 		}
 	};
 }
-function assertMutationDefaultGeneratorsAvailable(contract, generatorRegistry) {
-	const defaults = contract.execution?.mutations.defaults ?? [];
-	if (defaults.length === 0) return;
-	const missing = /* @__PURE__ */ new Set();
-	for (const mutationDefault of defaults) for (const phase of [mutationDefault.onCreate, mutationDefault.onUpdate]) {
-		if (!phase) continue;
-		if (phase.kind === "generator" && !generatorRegistry.has(phase.id)) missing.add(phase.id);
-	}
-	if (missing.size === 0) return;
-	const ids = Array.from(missing);
-	throw runtimeError("RUNTIME.MUTATION_DEFAULT_GENERATOR_MISSING", `Contract requires mutation default generator(s) ${ids.map((id) => `'${id}'`).join(", ")}, but no runtime component provides them.`, { ids });
-}
-function collectMutationDefaultGenerators(contributors) {
-	const generators = /* @__PURE__ */ new Map();
-	const owners = /* @__PURE__ */ new Map();
-	for (const contributor of contributors) {
-		const nextGenerators = contributor.mutationDefaultGenerators?.() ?? [];
-		for (const generator of nextGenerators) {
-			const existingOwner = owners.get(generator.id);
-			if (existingOwner !== void 0) throw runtimeError("RUNTIME.DUPLICATE_MUTATION_DEFAULT_GENERATOR", `Duplicate mutation default generator '${generator.id}'.`, {
-				id: generator.id,
-				existingOwner,
-				incomingOwner: contributor.id
-			});
-			generators.set(generator.id, generator);
-			owners.set(generator.id, contributor.id);
-		}
-	}
-	return generators;
-}
-function computeExecutionDefaultValue(spec, generatorRegistry) {
-	switch (spec.kind) {
-		case "generator": {
-			const generator = generatorRegistry.get(spec.id);
-			if (!generator) throw runtimeError("RUNTIME.MUTATION_DEFAULT_GENERATOR_MISSING", `Contract references mutation default generator '${spec.id}' but no runtime component provides it.`, { id: spec.id });
-			return generator.generate(spec.params);
-		}
-	}
-}
-function applyMutationDefaults(contract, generatorRegistry, options) {
-	const defaults = contract.execution?.mutations.defaults ?? [];
-	if (defaults.length === 0) return [];
-	const isEmptyUpdate = options.op === "update" && Object.keys(options.values).length === 0;
-	const applied = [];
-	const appliedColumns = /* @__PURE__ */ new Set();
-	const rowCache = /* @__PURE__ */ new Map();
-	for (const mutationDefault of defaults) {
-		if (mutationDefault.ref.entry !== options.table) continue;
-		if (mutationDefault.ref.namespace !== options.namespace) continue;
-		const defaultSpec = options.op === "create" ? mutationDefault.onCreate : mutationDefault.onUpdate;
-		if (!defaultSpec) continue;
-		if (isEmptyUpdate) continue;
-		const columnName = mutationDefault.ref.field;
-		if (Object.hasOwn(options.values, columnName) || appliedColumns.has(columnName)) continue;
-		applied.push({
-			column: columnName,
-			value: resolveScopedValue(defaultSpec, generatorRegistry, rowCache, options.defaultValueCache)
-		});
-		appliedColumns.add(columnName);
-	}
-	return applied;
-}
-function resolveScopedValue(spec, generatorRegistry, rowCache, queryCache) {
-	if (spec.kind !== "generator") return computeExecutionDefaultValue(spec, generatorRegistry);
-	const cache = scopedCache(generatorRegistry.get(spec.id)?.stability, rowCache, queryCache);
-	if (!cache) return computeExecutionDefaultValue(spec, generatorRegistry);
-	if (cache.has(spec.id)) return cache.get(spec.id);
-	const value = computeExecutionDefaultValue(spec, generatorRegistry);
-	cache.set(spec.id, value);
-	return value;
-}
-function scopedCache(stability, rowCache, queryCache) {
-	switch (stability) {
-		case "row": return rowCache;
-		case "query": return queryCache;
-		default: return;
-	}
-}
 function createExecutionContext(options) {
 	const { stack, driver } = options;
 	assertExecutionStackContractRequirements(options.contract, stack);
@@ -861,7 +783,7 @@ function createExecutionContext(options) {
 	assertColumnCodecIntegrity(contract.storage, codecDescriptors);
 	const aggregateDescriptors = buildSqlAggregateDescriptorRegistry(collectAggregateDescriptorContributions(contributors), codecDescriptors);
 	const mutationDefaultGeneratorRegistry = collectMutationDefaultGenerators(contributors);
-	assertMutationDefaultGeneratorsAvailable(contract, mutationDefaultGeneratorRegistry);
+	assertMutationDefaultGeneratorsAvailable(contract.execution, mutationDefaultGeneratorRegistry);
 	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
 	const types = initializeTypeHelpers(contract.storage, documentScopedCodecTypes(contract), parameterizedCodecDescriptors);
 	return {
@@ -871,7 +793,7 @@ function createExecutionContext(options) {
 		aggregateDescriptors,
 		queryOperations: queryOperationRegistry,
 		types,
-		applyMutationDefaults: (options) => applyMutationDefaults(contract, mutationDefaultGeneratorRegistry, options)
+		applyMutationDefaults: (options) => applyMutationDefaults(contract.execution, mutationDefaultGeneratorRegistry, options)
 	};
 }
 const sqlNativeArrayListDecoder = async (wireValue, decodeElement) => {