@prisma/orm-family-sql 8.0.0-rc.17-dev.26 → 8.0.0-rc.17-dev.28

package/dist/{prepared-statement-YtgdlN7e-DqHHwo30.d.mts → prepared-statement-Bs9TKj5u-CInk8vXF.d.mts}

@@ -2,7 +2,7 @@ import { l as SqlStorage } from "./sql-storage-BTlJLUID-CGy3wuH4.mjs";
 import "./types-Uv3oTMAb.mjs";
 import { r as SqlOperationDescriptors } from "./index-We-mbWnZ.mjs";
 import { E as CodecRef$1, Pt as SqlCodecCallContext, S as Codec$1, h as AnyQueryAst, ht as LoweredStatement, k as ContractCodecRegistry, mt as LoweredParam } from "./types-Sh5HuaZE-CqThc46M.mjs";
-import { c as SqlQueryable, i as SqlDriver, l as SqlStatementStats, r as SqlConnection, u as SqlTransaction } from "./driver-types-DRsYeq3j-X_D6hNMZ.mjs";
+import { c as SqlQueryable, i as SqlDriver, l as SqlStatementStats, r as SqlConnection } from "./driver-types-DRsYeq3j-X_D6hNMZ.mjs";
 import { n as SqlQueryPlan } from "./plan-cGEaSXHv-j0w37mVT.mjs";
 import { a as CodecValue, i as CodecTypesBase, l as RawCodecInferer, o as Expression, t as AffectedCount } from "./expression-Ck1wys3N-RNyviMcU.mjs";
 import "./expression-DWcDQHh9.mjs";
@@ -13,13 +13,13 @@ import { n as ExecutionContext } from "./query-lane-context-C2AXsoFa-COSQOvZz.mj
 import "./query-lane-context-BsZs5lvB.mjs";
 import { h as RuntimeScope } from "./types-D09NAayg-CNrpjo7Z.mjs";
 import "./types-DAkmn9FV.mjs";
-import { i as SqlParamRefMutator } from "./middleware-mLwvcOLS-wIYSKgog.mjs";
-import "./middleware-FHkIPvYR.mjs";
+import { i as SqlParamRefMutator } from "./middleware-YsFLC19Y-xhimGDiS.mjs";
+import "./middleware-DOKGNt72.mjs";
 import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
 import { Contract, JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
-import { AfterExecuteResult, AfterQueryResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, MutationDefaultGeneratorContributor, QueryInterceptResult, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware, RuntimeMiddlewareContext } from "@prisma/orm-framework/components/runtime";
+import { ActivityContext, ActivityEndedResult, ActivityFinalizedResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, MutationDefaultGeneratorContributor, QueryInterceptResult, RuntimeActivity, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware } from "@prisma/orm-framework/components/runtime";
 import { ExecutionStack, RuntimeAdapterDescriptor, RuntimeAdapterInstance, RuntimeDriverDescriptor, RuntimeDriverInstance, RuntimeExtensionDescriptor, RuntimeExtensionInstance, RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma/orm-framework/components/execution";
-//#region ../../../2-sql/5-runtime/dist/prepared-statement-YtgdlN7e.d.mts
+//#region ../../../2-sql/5-runtime/dist/prepared-statement-Bs9TKj5u.d.mts
 //#region src/codecs/encoding.d.ts
 interface ParamMetadata {
   readonly codec: CodecRef$1 | undefined;
@@ -29,7 +29,7 @@ declare function deriveParamMetadata(ast: AnyQueryAst): readonly ParamMetadata[]
 declare function encodeParamsWithMetadata(values: readonly unknown[], metadata: readonly ParamMetadata[], ctx: SqlCodecCallContext, contractCodecs?: ContractCodecRegistry): Promise<readonly unknown[]>;
 //#endregion
 //#region src/middleware/sql-middleware.d.ts
-interface SqlMiddlewareContext extends RuntimeMiddlewareContext {
+interface SqlMiddlewareContext extends ActivityContext {
   readonly contract: Contract<SqlStorage>;
 }
 /**
@@ -42,6 +42,9 @@ interface DraftPlan {
 }
 interface SqlMiddleware<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends RuntimeMiddleware<SqlExecutionPlan, SqlParamRefMutator<TCodecMap>> {
   readonly familyId?: 'sql';
+  activityStarted?(activity: RuntimeActivity, ctx: SqlMiddlewareContext): Promise<void>;
+  activityEnded?(activity: RuntimeActivity, result: ActivityEndedResult, ctx: SqlMiddlewareContext): Promise<void>;
+  activityFinalized?(activity: RuntimeActivity, result: ActivityFinalizedResult, ctx: SqlMiddlewareContext): Promise<void>;
   /**
    * Rewrite the query AST before it is lowered to SQL. Middlewares run in
    * registration order; each sees the predecessor's output, so rewrites
@@ -62,62 +65,16 @@ interface SqlMiddleware<TCodecMap extends Record<string, unknown> = Record<strin
    */
   beforeCompile?(draft: DraftPlan, ctx: SqlMiddlewareContext): Promise<DraftPlan | undefined>;
   /**
-   * Mutate `ParamRef.value` slots before encode runs. The third
-   * `params` argument is a {@link SqlParamRefMutator} scoped to value
-   * slots only — SQL strings, projections, and `ParamRef` membership
-   * are not mutable. Existing `(plan)` and `(plan, ctx)` middleware
-   * bodies that ignore the additional argument continue to compile
-   * and run unchanged.
+   * Runs after lowering, before parameter encoding: `beforeCompile → lowerSqlPlan → beforeEncode → encodeParams → intercept → driver`. Throw to block the statement.
    *
-   * Lifecycle position:
-   *   `beforeCompile → lowerSqlPlan → beforeQuery → encodeParams → interceptQuery → driver query`.
-   *
-   * The plan handed in is the SQL execution plan after lowering but
-   * *before* parameter encoding: `plan.params[i]` is the user-domain
-   * value the mutator's `entries()` iterator surfaces (e.g. an
-   * `EncryptedEnvelopeBase` for a cipherstash-codec'd column, or a
-   * plain JS value for non-codec'd ParamRefs). Mutations applied via
-   * `params.replaceValue` / `replaceValues` are visible to encode,
-   * which then renders the mutated value through the column's codec.
-   *
-   * `ctx.signal` carries the per-operation `AbortSignal` (ADR 207);
-   * middleware that wraps a network SDK forwards `ctx.signal` to
-   * that SDK. Cooperative cancellation: a body that ignores the
-   * signal still surfaces `RUNTIME.ABORTED { phase: 'beforeQuery' }`
-   * promptly via the runtime's race against the signal.
+   * `plan.params[i]` is the user-domain value the mutator's `entries()` surfaces. Changes made through `params.replaceValue` / `replaceValues` are encoded through the column's codec. A body that ignores `ctx.signal` still fails promptly with `RUNTIME.ABORTED { phase: 'beforeEncode' }`.
    */
-  beforeQuery?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext, params?: SqlParamRefMutator<TCodecMap>): void | Promise<void>;
-  interceptQuery?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<QueryInterceptResult | undefined>;
+  beforeEncode?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext, params?: SqlParamRefMutator<TCodecMap>): void | Promise<void>;
+  intercept?: {
+    onQuery?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<QueryInterceptResult | undefined>;
+    onExecute?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<ExecuteInterceptResult | undefined>;
+  };
   onRow?(row: Record<string, unknown>, plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<void>;
-  afterQuery?(plan: SqlExecutionPlan, result: AfterQueryResult, ctx: SqlMiddlewareContext): Promise<void>;
-  /**
-   * Mutate `ParamRef.value` slots before encode runs. The third
-   * `params` argument is a {@link SqlParamRefMutator} scoped to value
-   * slots only — SQL strings, projections, and `ParamRef` membership
-   * are not mutable. Existing `(plan)` and `(plan, ctx)` middleware
-   * bodies that ignore the additional argument continue to compile
-   * and run unchanged.
-   *
-   * Lifecycle position:
-   *   `beforeCompile → lowerSqlPlan → beforeExecute → encodeParams → interceptExecute → driver execute`.
-   *
-   * The plan handed in is the SQL execution plan after lowering but
-   * *before* parameter encoding: `plan.params[i]` is the user-domain
-   * value the mutator's `entries()` iterator surfaces (e.g. an
-   * `EncryptedEnvelopeBase` for a cipherstash-codec'd column, or a
-   * plain JS value for non-codec'd ParamRefs). Mutations applied via
-   * `params.replaceValue` / `replaceValues` are visible to encode,
-   * which then renders the mutated value through the column's codec.
-   *
-   * `ctx.signal` carries the per-operation `AbortSignal` (ADR 207);
-   * middleware that wraps a network SDK forwards `ctx.signal` to
-   * that SDK. Cooperative cancellation: a body that ignores the
-   * signal still surfaces `RUNTIME.ABORTED { phase: 'beforeExecute' }`
-   * promptly via the runtime's race against the signal.
-   */
-  beforeExecute?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext, params?: SqlParamRefMutator<TCodecMap>): void | Promise<void>;
-  interceptExecute?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<ExecuteInterceptResult | undefined>;
-  afterExecute?(plan: SqlExecutionPlan, result: AfterExecuteResult, ctx: SqlMiddlewareContext): Promise<void>;
 }
 //#endregion
 //#region src/codecs/decoding.d.ts
@@ -320,6 +277,35 @@ declare function createExecutionContext<TContract extends Contract<SqlStorage> =
   readonly driver?: RuntimeDriverDescriptor<'sql', TTargetId, unknown, SqlRuntimeDriverInstance<TTargetId>>;
 }): ExecutionContext<TContract>;
 //#endregion
+//#region src/transaction-state.d.ts
+/**
+ * What the database did with a transaction the runtime wrapped. `withTransaction` and the ORM read it to tell a failed `COMMIT` or `ROLLBACK` from an `activityEnded` hook that threw after the database had already settled the transaction.
+ */
+declare const transactionSettlement: unique symbol;
+interface TransactionSettlementState {
+  /** The driver's `COMMIT` resolved. */
+  readonly committed: boolean;
+  /** The driver's `ROLLBACK` resolved. */
+  readonly rolledBack: boolean;
+  /** Passes an `activityEnded` error the caller does not receive to the transaction's log, so it is not lost. */
+  logDroppedError(error: unknown): void;
+}
+interface SettledTransactionTarget {
+  readonly [transactionSettlement]: TransactionSettlementState;
+}
+declare function settlementOf(transaction: object): TransactionSettlementState | undefined;
+/**
+ * How the last transaction start on a connection the runtime made went. `withTransaction` releases the connection after a start the `activityStarted` hooks refused before any `BEGIN` was sent, and destroys it after any other start failure.
+ */
+declare const transactionStart: unique symbol;
+interface TransactionStart {
+  refusedBeforeBegin: boolean;
+}
+interface TransactionStartTarget {
+  readonly [transactionStart]: TransactionStart;
+}
+declare function createTransactionStart(): TransactionStart;
+//#endregion
 //#region src/sql-runtime.d.ts
 type Log = RuntimeLog;
 /**
@@ -405,9 +391,8 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
    * Implementation note: SQL splits lower-then-encode across
    * {@link lowerToDraft} + {@link encodeDraftParams} so the selected
    * operation's middleware chain can run between them:
-   * {@link prepareQueryExecution} uses `runBeforeQueryChain` for `query()`,
-   * while {@link prepareExecuteExecution} uses `runBeforeExecuteChain` for
-   * `execute()` (cipherstash bulk-encrypt, for example, mutates pre-encode
+   * {@link prepareOperation} runs the statement's `beforeEncode` chain
+   * between them (cipherstash bulk-encrypt, for example, mutates pre-encode
    * `ParamRef.value` slots). This protected hook composes the two back into
    * the cross-family `lower()` shape `RuntimeCore` expects. The production
    * operation methods use the matching split form before driver execution.
@@ -437,10 +422,8 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
   protected runDriver(exec: SqlExecutionPlan): AsyncIterable<Record<string, unknown>>;
   protected runExecute(exec: SqlExecutionPlan): Promise<SqlStatementStats>;
   /**
-   * SQL pre-compile hook. Runs the registered middleware `beforeCompile` chain over the plan's draft (AST + meta). Returns the original plan unchanged when no middleware rewrote the AST; otherwise returns a new plan carrying the rewritten AST and meta. The AST is the authoritative source of execution metadata, so a rewrite needs no sidecar reconciliation here — the lowering adapter and the encoder both walk the rewritten
-   * AST directly.
+   * Runs the registered middleware `beforeCompile` chain over the plan's draft (AST + meta). Returns the original plan unchanged when no middleware rewrote the AST; otherwise returns a new plan carrying the rewritten AST and meta. The lowering adapter and the encoder both walk the rewritten AST directly.
    */
-  protected runBeforeCompile(plan: SqlQueryPlan): Promise<SqlQueryPlan>;
   private compilePlan;
   query<Row>(plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & {
     readonly _row?: Row;
@@ -457,19 +440,17 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
   protected acquireRawConnection(): Promise<SqlConnection>;
   private setupDriverExecution;
   private beginOperation;
-  private scheduleAfterTransaction;
+  private parentOf;
   protected getListDecoder(): ListDecoder;
-  private streamRows;
   private streamDecodedRows;
   private createQueryContexts;
-  private prepareQueryExecution;
-  private prepareExecuteExecution;
   private prepareOperation;
   /** Query rows against a caller-supplied queryable through the shared preparation pipeline. */
   protected queryAgainstQueryable<Row>(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, queryable: SqlQueryable, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
   /** Execute statistics against a caller-supplied queryable through the shared preparation pipeline. */
   protected executeStatisticsAgainstQueryable(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, queryable: SqlQueryable, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
   private executeStatisticsInFlight;
+  private executeOn;
   private executeEncodedPlan;
   prepare<D extends Declaration<CT>, Row, CT extends CodecTypesBase = CodecTypesBase>(declaration: D, callback: PrepareCallback<D, Row>): Promise<PreparedFor<ParamsFromDeclaration<D, CT>, Row>>;
   /** Query prepared rows against a caller-supplied queryable through the full pipeline. */
@@ -478,12 +459,13 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
   /** Execute a prepared statement's statistics against a caller-supplied queryable through the full pipeline. */
   protected runPreparedExecuteAgainstQueryable<P>(ps: PreparedExecutionImpl<P>, userParams: unknown, queryable: SqlQueryable, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
   private runPreparedExecuteInFlight;
+  private executePrepared;
   connection(): Promise<RuntimeConnection>;
   /**
-   * Wraps a driver transaction so every query run on it passes through the runtime with `scope: 'transaction'`, and fires each query's `afterTransaction` stage once when the transaction ends. `connection` is the connection `driverTx` was begun on. A query sent on it, or on the transaction, from now until `commit()` or `rollback()` is called runs inside the transaction, so its stage also fires when the transaction ends. A subclass that begins a driver transaction itself returns it through this wrapper. A transaction a subclass wraps reads the contract marker through the driver; only the connections and transactions this class hands out read it through themselves.
+   * Begins a transaction on `connection`, which `owner` wraps, as a transaction activity. When the transaction's `activityStarted` hooks refuse the start, no `BEGIN` is sent, `owner` is recorded as clean, and `withTransaction` releases it; after any other start failure it destroys it. The transaction's `activityStarted` hooks run before `BEGIN`. Every statement sent on the transaction, or on `connection`, from the end of `BEGIN` until `commit()` or `rollback()` is called is the transaction's child, and is finalized when the transaction ends, with its outcome. `commit()` and `rollback()` resolve after every finalization hook has run. A subclass that holds its own connection begins its transactions here.
    */
-  protected wrapTransaction(driverTx: SqlTransaction, connection: SqlConnection): RuntimeTransaction;
-  private rememberQueriesUntilEnd;
+  protected beginTransactionOn(connection: SqlConnection, owner: TransactionStartTarget): Promise<RuntimeTransaction>;
+  private wrapTransaction;
   telemetry(): RuntimeTelemetryEvent | null;
   close(): Promise<void>;
   private closeDriverAfterWork;
@@ -492,9 +474,11 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
   private verifyMarker;
   private recordTelemetry;
 }
-/** Minimal structural type `withTransaction` depends on — anything that can open a connection. */
+/**
+ * Minimal structural type `withTransaction` depends on — anything that can open a connection. A connection the runtime made also carries its last transaction start, and its transactions carry their settlement; `withTransaction` reads both to decide whether a failure left the connection clean and which error to report.
+ */
 interface ConnectionProvider {
-  connection(): Promise<RuntimeConnection>;
+  connection(): Promise<RuntimeConnection & Partial<TransactionStartTarget>>;
 }
 declare function withTransaction<R>(runtime: ConnectionProvider, fn: (tx: TransactionContext) => PromiseLike<R>): Promise<R>;
 //#endregion
@@ -536,5 +520,5 @@ declare class PreparedExecutionImpl<Params> implements PreparedExecution<Params>
   execute(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
 }
 //#endregion
-export { SqlMiddlewareContext as A, TransactionContext as B, RuntimeParameterizedCodecDescriptor as C, SqlExecutionStack as D, RuntimeTransaction as E, SqlRuntimeExtensionDescriptor as F, encodeParamsWithMetadata as G, createExecutionContext as H, SqlRuntimeExtensionInstance as I, withTransaction as J, preparedStatementExecute as K, SqlRuntimeTargetDescriptor as L, SqlRuntimeAdapterInstance as M, SqlRuntimeBase as N, SqlExecutionStackWithDriver as O, SqlRuntimeDriverInstance as P, SqlStaticContributions as R, RuntimeOptions as S, RuntimeTelemetryEvent as T, createSqlExecutionStack as U, VerifyMarkerOption as V, deriveParamMetadata as W, PreparedStatementInternals as _, DeclaredCodecId as a, RuntimeConnection as b, ParamSpec as c, PreparedExecution as d, PreparedExecutionImpl as f, PreparedStatementImpl as g, PreparedStatementExecuteTarget as h, Declaration as i, SqlRuntimeAdapterDescriptor as j, SqlMiddleware as k, ParamsFromDeclaration as l, PreparedStatement as m, CloseRefusal as n, DeclaredNullable as o, PreparedFor as p, preparedStatementQuery as q, ConnectionProvider as r, MarkerReader as s, BindSiteParams as t, PrepareCallback as u, PreparedStatementQueryTarget as v, RuntimeQueryable as w, RuntimeFamilyAdapter as x, Runtime as y, TelemetryOutcome as z };
-//# sourceMappingURL=prepared-statement-YtgdlN7e-DqHHwo30.d.mts.map
+export { settlementOf as $, SqlMiddleware as A, TelemetryOutcome as B, RuntimeParameterizedCodecDescriptor as C, SettledTransactionTarget as D, RuntimeTransaction as E, SqlRuntimeDriverInstance as F, VerifyMarkerOption as G, TransactionSettlementState as H, SqlRuntimeExtensionDescriptor as I, createTransactionStart as J, createExecutionContext as K, SqlRuntimeExtensionInstance as L, SqlRuntimeAdapterDescriptor as M, SqlRuntimeAdapterInstance as N, SqlExecutionStack as O, SqlRuntimeBase as P, preparedStatementQuery as Q, SqlRuntimeTargetDescriptor as R, RuntimeOptions as S, RuntimeTelemetryEvent as T, TransactionStart as U, TransactionContext as V, TransactionStartTarget as W, encodeParamsWithMetadata as X, deriveParamMetadata as Y, preparedStatementExecute as Z, PreparedStatementInternals as _, DeclaredCodecId as a, RuntimeConnection as b, ParamSpec as c, PreparedExecution as d, transactionSettlement as et, PreparedExecutionImpl as f, PreparedStatementImpl as g, PreparedStatementExecuteTarget as h, Declaration as i, SqlMiddlewareContext as j, SqlExecutionStackWithDriver as k, ParamsFromDeclaration as l, PreparedStatement as m, CloseRefusal as n, withTransaction as nt, DeclaredNullable as o, PreparedFor as p, createSqlExecutionStack as q, ConnectionProvider as r, MarkerReader as s, BindSiteParams as t, transactionStart as tt, PrepareCallback as u, PreparedStatementQueryTarget as v, RuntimeQueryable as w, RuntimeFamilyAdapter as x, Runtime as y, SqlStaticContributions as z };
+//# sourceMappingURL=prepared-statement-Bs9TKj5u-CInk8vXF.d.mts.map

package/dist/prepared-statement-Bs9TKj5u-CInk8vXF.d.mts.map

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

package/dist/relational-core.d.mts

@@ -10,5 +10,5 @@ import "./plan-_8dKi13Q.mjs";
 import { a as SqlAggregateDescriptorRegistry, c as TypeHelperRegistry, n as ExecutionContext, r as ResolvedSqlAggregate, t as CodecDescriptorRegistry } from "./query-lane-context-C2AXsoFa-COSQOvZz.mjs";
 import "./query-lane-context-BsZs5lvB.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-D09NAayg-CNrpjo7Z.mjs";
-import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-mLwvcOLS-wIYSKgog.mjs";
+import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-YsFLC19Y-xhimGDiS.mjs";
 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, CapabilityRequirement, 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, DdlNode, DdlTableConstraint, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecJson, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EncodedLiteralDefault, EqColJoinOn, ExecutionContext, ExistsExpr, Expr, ExprVisitor, Expression, ExpressionFolder, ExpressionImpl, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ForeignKeyConstraint, FunctionCallExpr, FunctionColumnDefault, FunctionSource, FunctionSourceAlias, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonDocumentProjection, JsonObjectEntry, JsonObjectExpr, JsonValueProjectionVisitor, LimitOffsetValue, ListExpression, LiteralColumnDefault, LiteralDefaultColumn, LiteralExpr, LockConflict, LockOptionCapabilities, LockStrength, LockStrengthCapabilities, LockWaitOptions, LockWaitPolicy, LockWaitRequest, LockingClause, LockingClauseOptions, LoweredParam, LoweredStatement, Lowerer, LowererContext, META, MarkerReadResult, Meta, ModelDef, ModelMetadata, NativeJsonValueProjection, NoReservedRowColumn, NotExpr, NullCheckExpr, OpaqueSql, 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, StorageColumnScopeField, SubqueryExpr, TableDef, TableKey, TableMetadata, TableRef, TableSource, TablesOf, ToWhereExpr, TraitExpression, TypeHelperRegistry, UniqueConstraint, UpdateAst, WhereArg, WindowFn, WindowFuncExpr, aggregateFnNames, buildOperation, checkLimitOffset, codecOf, collectOrderedParamRefs, compact, createRawSql, createSqlParamRefMutator, encodeListLiteralDefault, encodeLiteralDefault, frozenCodecRef, isAggregateFn, isAggregateProjection, isDdlNode, isExpression, isOrderByDirection, isOrderByNulls, isQueryAst, isWhereExpr, lockIncompatible, lockOptionCapabilities, lockStrengthCapabilities, lockWaitPolicyOf, missingCapability, opaqueSql, param, planFromAst, queryAstKinds, renderOpaqueSql, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, toExpr, whereExprKinds };

package/dist/relational-core__middleware.d.mts

@@ -1,3 +1,3 @@
-import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-mLwvcOLS-wIYSKgog.mjs";
-import "./middleware-FHkIPvYR.mjs";
+import { a as SqlParamRefMutatorInternal, i as SqlParamRefMutator, n as ParamRefEntryUnion, o as createSqlParamRefMutator, r as ParamRefHandle, t as ParamRefEntry } from "./middleware-YsFLC19Y-xhimGDiS.mjs";
+import "./middleware-DOKGNt72.mjs";
 export { type ParamRefEntry, type ParamRefEntryUnion, type ParamRefHandle, type SqlParamRefMutator, type SqlParamRefMutatorInternal, createSqlParamRefMutator };

package/dist/runtime.d.mts

@@ -1,5 +1,5 @@
 import { m as MarkerReadResult } from "./ast-Dp6lQXUX.mjs";
 import { c as TypeHelperRegistry, n as ExecutionContext } from "./query-lane-context-C2AXsoFa-COSQOvZz.mjs";
-import { A as SqlMiddlewareContext, B as TransactionContext, C as RuntimeParameterizedCodecDescriptor, D as SqlExecutionStack, E as RuntimeTransaction, F as SqlRuntimeExtensionDescriptor, G as encodeParamsWithMetadata, H as createExecutionContext, I as SqlRuntimeExtensionInstance, J as withTransaction, L as SqlRuntimeTargetDescriptor, M as SqlRuntimeAdapterInstance, N as SqlRuntimeBase, O as SqlExecutionStackWithDriver, P as SqlRuntimeDriverInstance, R as SqlStaticContributions, S as RuntimeOptions, T as RuntimeTelemetryEvent, U as createSqlExecutionStack, V as VerifyMarkerOption, W as deriveParamMetadata, _ as PreparedStatementInternals, a as DeclaredCodecId, b as RuntimeConnection, c as ParamSpec, d as PreparedExecution, f as PreparedExecutionImpl, g as PreparedStatementImpl, i as Declaration, j as SqlRuntimeAdapterDescriptor, k as SqlMiddleware, l as ParamsFromDeclaration, m as PreparedStatement, n as CloseRefusal, o as DeclaredNullable, p as PreparedFor, r as ConnectionProvider, s as MarkerReader, t as BindSiteParams, u as PrepareCallback, w as RuntimeQueryable, x as RuntimeFamilyAdapter, y as Runtime, z as TelemetryOutcome } from "./prepared-statement-YtgdlN7e-DqHHwo30.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-ZHk0SsBA.mjs";
-export { type AfterExecuteResult, type AfterQueryResult, type BindSiteParams, type BudgetsOptions, type CloseRefusal, 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 };
+import { A as SqlMiddleware, B as TelemetryOutcome, C as RuntimeParameterizedCodecDescriptor, E as RuntimeTransaction, F as SqlRuntimeDriverInstance, G as VerifyMarkerOption, I as SqlRuntimeExtensionDescriptor, K as createExecutionContext, L as SqlRuntimeExtensionInstance, M as SqlRuntimeAdapterDescriptor, N as SqlRuntimeAdapterInstance, O as SqlExecutionStack, P as SqlRuntimeBase, R as SqlRuntimeTargetDescriptor, S as RuntimeOptions, T as RuntimeTelemetryEvent, V as TransactionContext, X as encodeParamsWithMetadata, Y as deriveParamMetadata, _ as PreparedStatementInternals, a as DeclaredCodecId, b as RuntimeConnection, c as ParamSpec, d as PreparedExecution, f as PreparedExecutionImpl, g as PreparedStatementImpl, i as Declaration, j as SqlMiddlewareContext, k as SqlExecutionStackWithDriver, l as ParamsFromDeclaration, m as PreparedStatement, n as CloseRefusal, nt as withTransaction, o as DeclaredNullable, p as PreparedFor, q as createSqlExecutionStack, r as ConnectionProvider, s as MarkerReader, t as BindSiteParams, u as PrepareCallback, w as RuntimeQueryable, x as RuntimeFamilyAdapter, y as Runtime, z as SqlStaticContributions } from "./prepared-statement-Bs9TKj5u-CInk8vXF.mjs";
+import { _ as lowerSqlPlan, a as LintsOptions, c as RuntimeActivity, d as TransactionActivity, f as TransactionEnded, g as lints, h as extractCodecIds, i as ExecuteInterceptResult, l as StatementActivity, m as createAstCodecRegistry, n as ActivityFinalizedResult, o as Log, p as budgets, r as BudgetsOptions, s as QueryInterceptResult, t as ActivityEndedResult, u as StatementEnded, v as validateCodecRegistryCompleteness, y as validateContractCodecMappings } from "./index-qr6LA3dl.mjs";
+export { type ActivityEndedResult, type ActivityFinalizedResult, type BindSiteParams, type BudgetsOptions, type CloseRefusal, 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 RuntimeActivity, 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 StatementActivity, type StatementEnded, type TelemetryOutcome, type TransactionActivity, type TransactionContext, type TransactionEnded, type TypeHelperRegistry, type VerifyMarkerOption, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, lints, lowerSqlPlan, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };