@prisma/orm-family-sql 8.0.0-rc.18-dev.5 → 8.0.0-rc.18-dev.6

package/dist/{prepared-statement-BwHkxfuI-CKkkrS6r.d.mts → index-UHjF-U84.d.mts}

@@ -4,31 +4,45 @@ 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 } 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 { i as CodecTypesBase, l as RawCodecInferer } from "./expression-Ck1wys3N-RNyviMcU.mjs";
 import "./expression-DWcDQHh9.mjs";
 import { m as MarkerReadResult, t as Adapter } from "./ast-Dp6lQXUX.mjs";
 import { t as SqlExecutionPlan } from "./sql-execution-plan-C7XauPPu-eskZJbmm.mjs";
 import "./plan-_8dKi13Q.mjs";
 import { n as CollectionMethodContribution } from "./collection-methods-BnR4UjcW-tiz3frtf.mjs";
-import { n as ExecutionContext } from "./query-lane-context-C42-u9L1-Bxa4DkI_.mjs";
+import { n as ExecutionContext, t as CodecDescriptorRegistry } from "./query-lane-context-C42-u9L1-Bxa4DkI_.mjs";
 import "./query-lane-context-DW5q2RAY.mjs";
-import { h as RuntimeScope } from "./types-Cl4MLNrS-lbf-K25i.mjs";
+import { _ as SqlOrmPlan, h as RuntimeScope } from "./types-Cl4MLNrS-lbf-K25i.mjs";
 import "./types-BkA6tyT-.mjs";
-import "./collection-methods-DoBrRR69.mjs";
+import { c as PreparedExecution, g as TransactionStartTarget, l as PreparedFor, n as Declaration, o as ParamsFromDeclaration, s as PrepareCallback, u as PreparedStatement, v as preparedStatementExecute, y as preparedStatementQuery } from "./transaction-state-DR3nKTmH-BZ-54Zu0.mjs";
 import { i as SqlParamRefMutator } from "./middleware-YsFLC19Y-xhimGDiS.mjs";
 import "./middleware-DOKGNt72.mjs";
+import "./collection-methods-DoBrRR69.mjs";
 import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
-import { Contract, JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
-import { ActivityContext, ActivityEndedResult, ActivityFinalizedResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, MutationDefaultGeneratorContributor, QueryInterceptResult, RuntimeActivity, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware } from "@prisma/orm-framework/components/runtime";
+import { Contract, PlanMeta } from "@prisma/orm-framework/contract/types";
+import { Activity, Activity as Activity$1, ActivityContext, ActivityEndedResult, ActivityEndedResult as ActivityEndedResult$1, ActivityFinalizedResult, ActivityFinalizedResult as ActivityFinalizedResult$1, ActivityInterceptResult, ActivityInterceptResult as ActivityInterceptResult$1, ActivityParent, ActivityParent as ActivityParent$1, AsyncIterableResult, ClientActivity, ClientActivity as ClientActivity$1, ClientActivityEnd, ClientActivityEnd as ClientActivityEnd$1, ClientActivityEnded, ClientActivityKind, ClientActivityKind as ClientActivityKind$1, ClientActivityResult, ClientActivityResult as ClientActivityResult$1, ExecuteInterceptResult, ExecuteInterceptResult as ExecuteInterceptResult$1, ExecutionPlan, MutationDefaultGeneratorContributor, QueryInterceptResult, QueryInterceptResult as QueryInterceptResult$1, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeLog as Log, RuntimeMiddleware, StartActivity, StartActivity as StartActivity$1, StatementActivity, StatementEnded, TransactionActivity, TransactionEnded } 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-BwHkxfuI.d.mts
-//#region src/codecs/encoding.d.ts
-interface ParamMetadata {
-  readonly codec: CodecRef$1 | undefined;
-  readonly name: string | undefined;
+//#region ../../../2-sql/5-runtime/dist/activity-handle-ZJxB73iI.d.mts
+//#region src/codecs/decoding.d.ts
+type ColumnRef = {
+  table: string;
+  column: string;
+};
+type ListDecoder = (wireValue: unknown, decodeElement: (value: unknown) => Promise<unknown>) => Promise<readonly unknown[]> | readonly unknown[];
+interface DecodeContext {
+  readonly aliases: ReadonlyArray<string> | undefined;
+  readonly codecs: ReadonlyMap<string, Codec$1>;
+  readonly columnRefs: ReadonlyMap<string, ColumnRef>;
+  readonly includeAliases: ReadonlySet<string>;
+  readonly manyAliases: ReadonlySet<string>;
+  /**
+   * Where {@link DecodeContext.aliases} came from, which decides how a row
+   * that lacks one of them reads: a projection the builder wrote is the
+   * runtime's own doing, while a row spec is the author's declaration about a
+   * statement the runtime never inspected.
+   */
+  readonly aliasSource: 'projection' | 'row-spec';
 }
-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 ActivityContext {
@@ -44,9 +58,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>;
+  activityStarted?(activity: Activity, ctx: SqlMiddlewareContext): Promise<void>;
+  activityEnded?(activity: Activity, result: ActivityEndedResult, ctx: SqlMiddlewareContext): Promise<void>;
+  activityFinalized?(activity: Activity, 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
@@ -75,101 +89,55 @@ interface SqlMiddleware<TCodecMap extends Record<string, unknown> = Record<strin
   intercept?: {
     onQuery?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<QueryInterceptResult | undefined>;
     onExecute?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<ExecuteInterceptResult | undefined>;
+    onActivity?(activity: ClientActivity, ctx: SqlMiddlewareContext): Promise<ActivityInterceptResult | undefined>;
   };
   onRow?(row: Record<string, unknown>, plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<void>;
 }
 //#endregion
-//#region src/codecs/decoding.d.ts
-type ColumnRef = {
-  table: string;
-  column: string;
-};
-type ListDecoder = (wireValue: unknown, decodeElement: (value: unknown) => Promise<unknown>) => Promise<readonly unknown[]> | readonly unknown[];
-interface DecodeContext {
-  readonly aliases: ReadonlyArray<string> | undefined;
-  readonly codecs: ReadonlyMap<string, Codec$1>;
-  readonly columnRefs: ReadonlyMap<string, ColumnRef>;
-  readonly includeAliases: ReadonlySet<string>;
-  readonly manyAliases: ReadonlySet<string>;
-  /**
-   * Where {@link DecodeContext.aliases} came from, which decides how a row
-   * that lacks one of them reads: a projection the builder wrote is the
-   * runtime's own doing, while a row spec is the author's declaration about a
-   * statement the runtime never inspected.
-   */
-  readonly aliasSource: 'projection' | 'row-spec';
+//#region src/codecs/encoding.d.ts
+interface ParamMetadata {
+  readonly codec: CodecRef$1 | undefined;
+  readonly name: string | undefined;
 }
+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/prepared/types.d.ts
-type ParamSpec<CT extends CodecTypesBase = CodecTypesBase> = (keyof CT & string) | {
-  readonly codecId: keyof CT & string;
-  readonly typeParams?: JsonValue;
-  readonly nullable?: boolean;
-};
-type Declaration<CT extends CodecTypesBase = CodecTypesBase> = Readonly<Record<string, ParamSpec<CT>>>;
-type DeclaredCodecId<S> = S extends string ? S : S extends {
-  readonly codecId: infer C extends string;
-} ? C : never;
-type DeclaredNullable<S> = S extends {
-  readonly nullable: true;
-} ? true : false;
-type BindSiteParams<D> = { readonly [K in keyof D]: Expression<{
-  codecId: DeclaredCodecId<D[K]>;
-  nullable: DeclaredNullable<D[K]>;
-}>; };
-type ParamsFromDeclaration<D, CT extends CodecTypesBase> = { readonly [K in keyof D]: CodecValue<DeclaredCodecId<D[K]>, DeclaredNullable<D[K]>, CT>; };
-type PrepareCallback<D, Row> = (params: BindSiteParams<D>) => SqlQueryPlan<Row>;
-interface PreparedStatement<Params, Row> {
+//#region src/prepared/prepared-statement.d.ts
+interface PreparedStatementInternals {
   readonly sql: string;
   readonly ast: AnyQueryAst;
   readonly meta: PlanMeta;
   readonly slots: readonly LoweredParam[];
-  readonly _params?: Params;
-  readonly _row?: Row;
-  query(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  readonly decodeContext: DecodeContext;
+  readonly paramMetadata: readonly ParamMetadata[];
 }
-/**
- * A prepared statement whose plan declares statement statistics rather than
- * rows. It carries the same lowered statement and bind slots as its
- * row-streaming sibling and differs in one way: it is consumed by executing
- * it, which resolves the statistics the statement reports.
- */
-interface PreparedExecution<Params> {
+declare class PreparedStatementImpl<Params, Row> implements PreparedStatement<Params, Row>, PreparedStatementInternals {
   readonly sql: string;
   readonly ast: AnyQueryAst;
   readonly meta: PlanMeta;
   readonly slots: readonly LoweredParam[];
-  readonly _params?: Params;
-  execute(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
+  readonly decodeContext: DecodeContext;
+  readonly paramMetadata: readonly ParamMetadata[];
+  constructor(internals: PreparedStatementInternals);
+  query(target: RuntimeScope, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
 }
 /**
- * The prepared handle a plan earns, keyed on the result the plan declares:
- * statistics prepare into a {@link PreparedExecution}, rows into a
- * {@link PreparedStatement}. The two faces share no consumption method, so a
- * handle cannot be read the wrong way round.
- *
- * The key is `AffectedCount`'s brand rather than the statistics shape, so a
- * row spec free to declare a column named `affectedRows` cannot select the
- * execution face by coincidence. This is the same fact `prepare()` reads at
- * runtime from the AST's declared result — one decision, stated twice.
+ * The statistics-reporting sibling of {@link PreparedStatementImpl}. A plan
+ * declaring an affected-row count prepares into one of these, which carries
+ * the same lowered statement and bind slots and is consumed by executing it.
  *
- * `never` is answered first because it satisfies every `extends`: a builder
- * state that projects nothing types its rows as `never`, and such a plan
- * declares rows in its AST, so it earns the statement face the runtime builds
- * for it.
+ * The two classes are separate so the consumption a plan did not declare is
+ * absent from the value, not merely from its type.
  */
-type PreparedFor<Params, Row> = [Row] extends [never] ? PreparedStatement<Params, Row> : [Row] extends [AffectedCount] ? PreparedExecution<Params> : PreparedStatement<Params, Row>;
-//#endregion
-//#region src/prepared/prepared-execute.d.ts
-declare const preparedStatementExecute: unique symbol;
-interface PreparedStatementExecuteTarget extends RuntimeQueryable {
-  [preparedStatementExecute]<Params>(statement: PreparedExecution<Params>, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
-}
-//#endregion
-//#region src/prepared/prepared-query.d.ts
-declare const preparedStatementQuery: unique symbol;
-interface PreparedStatementQueryTarget extends RuntimeQueryable {
-  [preparedStatementQuery]<Params, Row>(statement: PreparedStatement<Params, Row>, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+declare class PreparedExecutionImpl<Params> implements PreparedExecution<Params>, PreparedStatementInternals {
+  readonly sql: string;
+  readonly ast: AnyQueryAst;
+  readonly meta: PlanMeta;
+  readonly slots: readonly LoweredParam[];
+  readonly decodeContext: DecodeContext;
+  readonly paramMetadata: readonly ParamMetadata[];
+  constructor(internals: PreparedStatementInternals);
+  execute(target: RuntimeScope, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
 }
 //#endregion
 //#region src/runtime-spi.d.ts
@@ -280,37 +248,8 @@ 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;
+type Log$1 = RuntimeLog;
 /**
  * When `close()` starts refusing new runtime-scope work. `'when-idle'` (the default) waits until the runtime has been idle for one turn of the event loop, so work that keeps it busy from the close onward is admitted; use it for an owner with one caller, such as a per-request connection. `'at-once'` refuses from the call of `close()`; use it for an owner that many callers share. Both wait for work already in flight.
  */
@@ -322,7 +261,7 @@ interface RuntimeOptions<TContract extends Contract<SqlStorage> = Contract<SqlSt
   readonly verifyMarker?: VerifyMarkerOption;
   readonly middleware?: readonly SqlMiddleware[];
   readonly mode?: 'strict' | 'permissive';
-  readonly log?: Log;
+  readonly log?: Log$1;
   readonly closeRefusal?: CloseRefusal | undefined;
 }
 /**
@@ -366,6 +305,22 @@ interface RuntimeQueryable extends RuntimeScope {}
 interface TransactionContext extends RuntimeQueryable {
   readonly invalidated: boolean;
 }
+/**
+ * The route a client activity's statements and transaction take to the database. A subclass whose statements run on its own sessions, such as role sessions, builds one and starts activities on it with `startActivityOnRoute`.
+ */
+interface ActivityRoute {
+  readonly scope: 'runtime' | 'connection' | 'transaction';
+  /** The parent of an activity started on the route itself. */
+  parent(): ActivityParent | undefined;
+  query<Row>(plan: SqlOrmPlan<Row>, options: ActivityExecuteOptions): AsyncIterableResult<Row>;
+  execute(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, options: ActivityExecuteOptions): Promise<SqlStatementStats>;
+  preparedQuery<Params, Row>(statement: PreparedStatementImpl<Params, Row>, params: Params, options: ActivityExecuteOptions): AsyncIterableResult<Row>;
+  preparedExecute<Params>(statement: PreparedExecutionImpl<Params>, params: Params, options: ActivityExecuteOptions): Promise<SqlStatementStats>;
+  /** Begins a transaction beneath `parent`; absent where the route is a transaction. */
+  readonly transaction: ((parent: ActivityParent) => Promise<RuntimeTransaction>) | undefined;
+  /** Whether an open activity on the route is runtime work that `close()` waits for. */
+  readonly runtimeWork: boolean;
+}
 /**
  * Abstract family-layer base for SQL runtimes. Subclass to build a target runtime
  * (e.g. `PostgresRuntimeImpl`); app code should consume the `Runtime` interface returned
@@ -434,6 +389,24 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
   execute(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
   [preparedStatementQuery]<Params, Row>(ps: PreparedStatement<Params, Row>, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
   [preparedStatementExecute]<Params>(ps: PreparedExecution<Params>, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
+  readonly [activitySource]: ActivitySource;
+  /**
+   * Starts a client activity whose statements and transaction run on `route`, beneath `parent` or, without one, beneath `route.parent()`.
+   */
+  protected startActivityOnRoute<K extends ClientActivityKind>(route: ActivityRoute, activity: StartActivity<K>, parent: ActivityParent | undefined): Promise<ActivityHandle<K>>;
+  /** The content hash of the statement `plan` would send on a queryable of `scope` beneath `parent`. */
+  protected planContentHashFor(plan: SqlQueryPlan | SqlExecutionPlan, scope: ActivityRoute['scope'], parent: ActivityParent | undefined): Promise<string>;
+  /** An activity route whose statements run on `queryable`. */
+  protected queryableRoute(queryable: SqlQueryable, scope: ActivityRoute['scope'], parent: () => ActivityParent | undefined, options: Pick<ActivityRoute, 'transaction' | 'runtimeWork'>): ActivityRoute;
+  /** The activity route of a held connection that `owner` wraps: its statements run on `connection`, and its transactions begin there. */
+  protected connectionRoute(connection: SqlConnection, owner: TransactionStartTarget): ActivityRoute;
+  private beginTransactionBeneathOn;
+  /** The `activitySource` member of a held connection that `owner()` wraps. */
+  protected connectionActivitySource(connection: SqlConnection, owner: () => TransactionStartTarget): ActivitySource;
+  private activityHandle;
+  private beginOwnedTransactionBeneath;
+  /** Begins a transaction with `begin` on a connection the transaction owns; see `beginOwnedTransaction`. */
+  protected ownTransaction(connection: Pick<RuntimeConnection, 'release' | 'destroy'>, begin: () => Promise<RuntimeTransaction>): Promise<RuntimeTransaction>;
   /**
    * Returns the raw driver connection. The connection is a `SqlQueryable` — SQL
    * issued on it runs below the middleware/codec/telemetry pipeline. It carries
@@ -442,6 +415,8 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
    */
   protected acquireRawConnection(): Promise<SqlConnection>;
   private setupDriverExecution;
+  private beginActivityWork;
+  private warnWhenWaitingOnlyForActivities;
   private beginOperation;
   private parentOf;
   protected getListDecoder(): ListDecoder;
@@ -449,25 +424,26 @@ declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = C
   private createQueryContexts;
   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>;
+  protected queryAgainstQueryable<Row>(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, queryable: SqlQueryable, options?: ActivityExecuteOptions): 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>;
+  protected executeStatisticsAgainstQueryable(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, queryable: SqlQueryable, options?: ActivityExecuteOptions): 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. */
-  protected runPreparedQueryAgainstQueryable<P, Row>(ps: PreparedStatementImpl<P, Row>, userParams: unknown, queryable: SqlQueryable, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  protected runPreparedQueryAgainstQueryable<P, Row>(ps: PreparedStatementImpl<P, Row>, userParams: unknown, queryable: SqlQueryable, options?: ActivityExecuteOptions): AsyncIterableResult<Row>;
   private streamPreparedRows;
   /** 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>;
+  protected runPreparedExecuteAgainstQueryable<P>(ps: PreparedExecutionImpl<P>, userParams: unknown, queryable: SqlQueryable, options?: ActivityExecuteOptions): Promise<SqlStatementStats>;
   private runPreparedExecuteInFlight;
   private executePrepared;
   connection(): Promise<RuntimeConnection>;
+  private openConnection;
   /**
    * 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 beginTransactionOn(connection: SqlConnection, owner: TransactionStartTarget): Promise<RuntimeTransaction>;
+  protected beginTransactionOn(connection: SqlConnection, owner: TransactionStartTarget, parent: ActivityParent | undefined): Promise<RuntimeTransaction>;
   private wrapTransaction;
   telemetry(): RuntimeTelemetryEvent | null;
   close(): Promise<void>;
@@ -485,43 +461,114 @@ interface ConnectionProvider {
 }
 declare function withTransaction<R>(runtime: ConnectionProvider, fn: (tx: TransactionContext) => PromiseLike<R>): Promise<R>;
 //#endregion
-//#region src/prepared/prepared-statement.d.ts
-interface PreparedStatementInternals {
-  readonly sql: string;
-  readonly ast: AnyQueryAst;
-  readonly meta: PlanMeta;
-  readonly slots: readonly LoweredParam[];
-  readonly decodeContext: DecodeContext;
-  readonly paramMetadata: readonly ParamMetadata[];
+//#region src/activity-handle.d.ts
+/** What starts client activities and hashes plans. The runtime's queryables and activity handles carry one through `activitySource`. */
+interface ActivitySource {
+  /**
+   * Starts an activity for an act the runtime would not otherwise see, such as an ORM call. Statements and activities started through the handle are its children. An open handle on the runtime keeps the runtime busy, so `close()` waits for its `end()`; a handle never ended keeps it busy, as a connection never released does.
+   */
+  startActivity<K extends ClientActivityKind>(activity: StartActivity<K>): Promise<ActivityHandle<K>>;
+  /** The content hash of the statement `plan` sends: after `beforeCompile`, lowering and encoding, without `beforeEncode`. It equals the digest `ctx.contentHash(exec)` returns for the statement's execution plan only when `beforeCompile` gives the same result here as for the statement (it runs here with the scope and parent of the queryable it is called on, and with fresh state; on the runtime itself there is no parent), no `beforeEncode` hook changes the parameters, and the codecs encode deterministically. It starts nothing, so it also works on a handle that has ended. */
+  planContentHash(plan: SqlQueryPlan | SqlExecutionPlan): Promise<string>;
 }
-declare class PreparedStatementImpl<Params, Row> implements PreparedStatement<Params, Row>, PreparedStatementInternals {
-  readonly sql: string;
-  readonly ast: AnyQueryAst;
-  readonly meta: PlanMeta;
-  readonly slots: readonly LoweredParam[];
-  readonly decodeContext: DecodeContext;
-  readonly paramMetadata: readonly ParamMetadata[];
-  constructor(internals: PreparedStatementInternals);
-  query(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+/** An open client activity, to send its statements through and to end. Its `startActivity` and `planContentHash` members are those of its `activitySource` member. */
+interface ActivityHandle<K extends ClientActivityKind> extends RuntimeQueryable, ActivitySource, ActivitySourceTarget {
+  readonly activity: ClientActivity<K>;
+  /** Set when an `intercept.onActivity` handler supplied the result; the client then returns it without running anything. */
+  readonly intercepted: {
+    readonly result: ClientActivityResult<K>;
+  } | undefined;
+  /** Starts a transaction beneath the activity. Absent on a handle opened under a transaction, or on a connection whose transaction is open. */
+  readonly transaction?: () => Promise<RuntimeTransaction>;
+  /** Ends the activity. Rejects with `RUNTIME.ACTIVITY_CHILDREN_OPEN` when a statement or activity beneath it has not ended, after ending it `failed`. */
+  end(end: ClientActivityEnd<K>): Promise<void>;
 }
+/** Options a queryable's statements carry: the activity they start beneath. */
+interface ActivityExecuteOptions extends RuntimeExecuteOptions {
+  readonly activityParent?: ActivityParent | undefined;
+}
+/** The symbol-keyed member through which a runtime, connection, transaction, `withTransaction` context or activity handle starts activities; user-facing types do not show it. */
+declare const activitySource: unique symbol;
+interface ActivitySourceTarget {
+  readonly [activitySource]: ActivitySource;
+}
+/** The `activitySource` member of a queryable; `undefined` for a queryable that cannot start activities, such as a test stub. */
+declare function findActivitySource(target: RuntimeScope): ActivitySource | undefined;
+/** An activity source that starts activities on whatever queryable `target()` returns when called, for an object that sends its statements to a queryable it looks up each time. */
+declare function delegatingActivitySource(target: () => RuntimeScope): ActivitySource;
+/** Starts an activity on a queryable through its `activitySource` member. */
+declare function startActivityOn<K extends ClientActivityKind>(target: RuntimeScope, activity: StartActivity<K>): Promise<ActivityHandle<K>>;
+declare function planContentHashOn(target: RuntimeScope, plan: SqlQueryPlan | SqlExecutionPlan): Promise<string>;
+//#endregion
+//#region ../../../2-sql/5-runtime/dist/index.d.mts
+//#region src/codecs/ast-codec-registry.d.ts
 /**
- * The statistics-reporting sibling of {@link PreparedStatementImpl}. A plan
- * declaring an affected-row count prepares into one of these, which carries
- * the same lowered statement and bind slots and is consumed by executing it.
+ * Build a contract-free {@link ContractCodecRegistry} that resolves codecs
+ * purely from AST-supplied {@link import('@prisma/orm-framework/components/codec').CodecRef}s
+ * against a target's descriptor registry.
  *
- * The two classes are separate so the consumption a plan did not declare is
- * absent from the value, not merely from its type.
+ * Dispatch is driven entirely by `CodecRef`s embedded in AST nodes; no
+ * contract walk is needed. `forColumn` always returns `undefined` — this
+ * registry carries no column-to-codec mappings.
  */
-declare class PreparedExecutionImpl<Params> implements PreparedExecution<Params>, PreparedStatementInternals {
-  readonly sql: string;
-  readonly ast: AnyQueryAst;
-  readonly meta: PlanMeta;
-  readonly slots: readonly LoweredParam[];
-  readonly decodeContext: DecodeContext;
-  readonly paramMetadata: readonly ParamMetadata[];
-  constructor(internals: PreparedStatementInternals);
-  execute(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
+declare function createAstCodecRegistry(descriptors: CodecDescriptorRegistry): ContractCodecRegistry;
+//#endregion
+//#region src/codecs/validation.d.ts
+declare function extractCodecIds(contract: Contract<SqlStorage>): Set<string>;
+declare function validateContractCodecMappings(registry: CodecDescriptorRegistry, contract: Contract<SqlStorage>): void;
+declare function validateCodecRegistryCompleteness(registry: CodecDescriptorRegistry, contract: Contract<SqlStorage>): void;
+//#endregion
+//#region src/lower-sql-plan.d.ts
+/**
+ * Lowers a SQL query plan to an executable Plan by calling the adapter's lower method.
+ *
+ * Ad-hoc lowerings produce only `{kind: 'literal'}` slots; this helper
+ * unwraps them into the bare-value array `SqlExecutionPlan` exposes.
+ * Encountering a `{kind: 'bind'}` slot here means the caller passed an
+ * AST containing `PreparedParamRef` to the ad-hoc execute path — that's a
+ * caller error, surfaced as `RUNTIME.PREPARE_BIND_ON_ADHOC`.
+ */
+declare function lowerSqlPlan<Row>(adapter: Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>, contract: Contract<SqlStorage>, queryPlan: SqlQueryPlan<Row>): SqlExecutionPlan<Row>;
+//#endregion
+//#region src/middleware/budgets.d.ts
+interface BudgetsOptions {
+  readonly maxRows?: number;
+  readonly defaultTableRows?: number;
+  readonly tableRows?: Record<string, number>;
+  readonly maxLatencyMs?: number;
+  readonly severities?: {
+    readonly rowCount?: 'warn' | 'error';
+    readonly latency?: 'warn' | 'error';
+  };
+}
+declare function budgets(options?: BudgetsOptions): SqlMiddleware;
+//#endregion
+//#region src/middleware/lints.d.ts
+interface LintsOptions {
+  readonly severities?: {
+    readonly selectStar?: 'warn' | 'error';
+    readonly noLimit?: 'warn' | 'error';
+    readonly deleteWithoutWhere?: 'warn' | 'error';
+    readonly updateWithoutWhere?: 'warn' | 'error';
+    readonly readOnlyMutation?: 'warn' | 'error';
+  };
+  readonly fallbackWhenAstMissing?: 'raw' | 'skip';
 }
+/**
+ * AST-first lint middleware for SQL plans. When `plan.ast` is a SQL QueryAst, inspects
+ * the AST structurally. When `plan.ast` is missing, falls back to raw heuristic
+ * guardrails or skips linting depending on `fallbackWhenAstMissing`.
+ *
+ * Rules (AST-based):
+ * - DELETE without WHERE: blocks execution (configurable severity, default error)
+ * - UPDATE without WHERE: blocks execution (configurable severity, default error)
+ * - Unbounded SELECT: warn/error (severity from noLimit)
+ * - SELECT * intent: warn/error (severity from selectStar)
+ *
+ * Fallback: When ast is missing, `fallbackWhenAstMissing: 'raw'` uses heuristic
+ * SQL parsing; `'skip'` skips all lints. Default is `'raw'`.
+ */
+declare function lints(options?: LintsOptions): SqlMiddleware;
 //#endregion
-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-BwHkxfuI-CKkkrS6r.d.mts.map
+export { SqlRuntimeBase as $, ActivityRoute as A, RuntimeConnection as B, extractCodecIds as C, validateContractCodecMappings as D, validateCodecRegistryCompleteness as E, MarkerReader as F, RuntimeTelemetryEvent as G, RuntimeOptions as H, PreparedExecutionImpl as I, SqlExecutionStackWithDriver as J, RuntimeTransaction as K, PreparedStatementImpl as L, ActivitySourceTarget as M, CloseRefusal as N, ActivityExecuteOptions as O, ConnectionProvider as P, SqlRuntimeAdapterInstance as Q, PreparedStatementInternals as R, createAstCodecRegistry as S, lowerSqlPlan as T, RuntimeParameterizedCodecDescriptor as U, RuntimeFamilyAdapter as V, RuntimeQueryable as W, SqlMiddlewareContext as X, SqlMiddleware as Y, SqlRuntimeAdapterDescriptor as Z, StatementActivity as _, withTransaction as _t, ActivityParent$1 as a, TelemetryOutcome as at, TransactionEnded as b, ClientActivityEnd$1 as c, activitySource as ct, ClientActivityResult$1 as d, delegatingActivitySource as dt, SqlRuntimeDriverInstance as et, ExecuteInterceptResult$1 as f, deriveParamMetadata as ft, StartActivity$1 as g, startActivityOn as gt, QueryInterceptResult$1 as h, planContentHashOn as ht, ActivityInterceptResult$1 as i, SqlStaticContributions as it, ActivitySource as j, ActivityHandle as k, ClientActivityEnded as l, createExecutionContext as lt, Log as m, findActivitySource as mt, ActivityEndedResult$1 as n, SqlRuntimeExtensionInstance as nt, BudgetsOptions as o, TransactionContext as ot, LintsOptions as p, encodeParamsWithMetadata as pt, SqlExecutionStack as q, ActivityFinalizedResult$1 as r, SqlRuntimeTargetDescriptor as rt, ClientActivity$1 as s, VerifyMarkerOption as st, Activity$1 as t, SqlRuntimeExtensionDescriptor as tt, ClientActivityKind$1 as u, createSqlExecutionStack as ut, StatementEnded as v, lints as w, budgets as x, TransactionActivity as y, Runtime as z };
+//# sourceMappingURL=index-UHjF-U84.d.mts.map

package/dist/index-UHjF-U84.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-UHjF-U84.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/activity-handle-ZJxB73iI.d.mts","../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":"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"}

package/dist/orm-client.d.mts

@@ -16,9 +16,9 @@ import { n as ExecutionContext } from "./query-lane-context-C42-u9L1-Bxa4DkI_.mj
 import "./query-lane-context-DW5q2RAY.mjs";
 import { h as RuntimeScope, o as ComputeColumnJsType } from "./types-Cl4MLNrS-lbf-K25i.mjs";
 import "./types-BkA6tyT-.mjs";
+import { l as PreparedFor, n as Declaration, o as ParamsFromDeclaration, t as BindSiteParams, u as PreparedStatement } from "./transaction-state-DR3nKTmH-BZ-54Zu0.mjs";
 import "./collection-methods-DoBrRR69.mjs";
-import { i as Declaration, l as ParamsFromDeclaration, m as PreparedStatement, p as PreparedFor, t as BindSiteParams, w as RuntimeQueryable$1, y as Runtime } from "./prepared-statement-BwHkxfuI-CKkkrS6r.mjs";
-import "./index-CmKqLvvO.mjs";
+import { M as ActivitySourceTarget, W as RuntimeQueryable$1, z as Runtime } from "./index-UHjF-U84.mjs";
 import { CodecDescriptorRef, ScalarFieldDeclarationBuilder } from "@prisma/orm-framework/components/codec";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { AnnotationValue, AsyncIterableResult, MetaBuilder, OperationKind, ResultType, RuntimeExecuteOptions } from "@prisma/orm-framework/components/runtime";
@@ -229,7 +229,8 @@ interface RuntimeTransaction extends RuntimeScope {
   commit?(): Promise<void>;
   rollback?(): Promise<void>;
 }
-interface RuntimeQueryable extends RuntimeScope {
+/** What the ORM sends its statements to. It may carry an `activitySource` member, as the SQL runtime's queryables do, through which `startActivityOn` reaches activities; a queryable without one, such as a test stub, has none. */
+interface RuntimeQueryable extends RuntimeScope, Partial<ActivitySourceTarget> {
   connection?(): Promise<RuntimeConnection>;
   transaction?(): Promise<RuntimeTransaction>;
 }