@prisma/orm-family-sql 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/index-7nHHQsAj.d.mts

@@ -0,0 +1,606 @@
+import { l as SqlStorage } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import "./types-CkAd8SWm.mjs";
+import { r as SqlOperationDescriptors } from "./index-Nqc3OHR_.mjs";
+import { E as CodecRef$1, Ft as SqlCodecCallContext, S as Codec$1, gt as LoweredStatement, h as AnyQueryAst, ht as LoweredParam, k as ContractCodecRegistry } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { c as SqlQueryable, i as SqlDriver, l as SqlStatementStats, r as SqlConnection } from "./driver-types-DRsYeq3j-BimeCnUk.mjs";
+import { n as SqlQueryPlan } from "./plan-Cr4azjnG-CuL8FqXC.mjs";
+import { i as CodecTypesBase, l as RawCodecInferer } from "./expression-6ld_ZQL6-fOuazzzm.mjs";
+import "./expression-D8HstQiB.mjs";
+import { m as MarkerReadResult, t as Adapter } from "./ast-YEMe_B8z.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-3uxYjHyu-DLknM-Pj.mjs";
+import "./plan-Di6Gs2JD.mjs";
+import { n as CollectionMethodContribution } from "./collection-methods-D2UnCS0S-DOy2qHYS.mjs";
+import { n as ExecutionContext, t as CodecDescriptorRegistry } from "./query-lane-context-BCEoKy0_-CzmyavC9.mjs";
+import "./query-lane-context-VqH0mS9B.mjs";
+import { _ as SqlOrmPlan, h as RuntimeScope } from "./types-TXO7x1BA-CYYIY8NI.mjs";
+import "./types-B9wSEUsV.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-D29jmVE-.mjs";
+import { i as SqlParamRefMutator } from "./middleware-DHkW6pRr-DM6hd9iZ.mjs";
+import "./middleware-gqy3l13N.mjs";
+import "./collection-methods-BB8YH69u.mjs";
+import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
+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-family/5-runtime/dist/activity-handle-Ax5eP79U.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';
+}
+//#endregion
+//#region src/middleware/sql-middleware.d.ts
+interface SqlMiddlewareContext extends ActivityContext {
+  readonly contract: Contract<SqlStorage>;
+}
+/**
+ * Pre-lowering query view passed to `beforeCompile`. Carries the typed SQL
+ * AST and plan metadata; `sql`/`params` are produced later by the adapter.
+ */
+interface DraftPlan {
+  readonly ast: AnyQueryAst;
+  readonly meta: PlanMeta;
+}
+interface SqlMiddleware<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends RuntimeMiddleware<SqlExecutionPlan, SqlParamRefMutator<TCodecMap>> {
+  readonly familyId?: 'sql';
+  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
+   * compose (e.g. soft-delete + tenant isolation).
+   *
+   * Return `undefined` (or a draft whose `ast` reference equals the input's)
+   * to pass through. Return a draft with a new `ast` reference to replace it;
+   * the runtime emits a `middleware.rewrite` debug log event and continues
+   * with the new draft. `adapter.lower()` runs once after the chain.
+   *
+   * Use `AstRewriter` / `SelectAst.withWhere` / `AndExpr.of` etc. to build
+   * the rewritten AST. Predicates and literals go through parameterized
+   * constructors by default — no SQL-injection surface is added. **Warning:**
+   * constructing `LiteralExpr.of(userInput)` from untrusted input bypasses
+   * that guarantee; use `ParamRef.of(userInput, ...)` instead.
+   *
+   * See `docs/architecture docs/subsystems/4. Runtime & Middleware Framework.md`.
+   */
+  beforeCompile?(draft: DraftPlan, ctx: SqlMiddlewareContext): Promise<DraftPlan | undefined>;
+  /**
+   * Runs after lowering, before parameter encoding: `beforeCompile → lowerSqlPlan → beforeEncode → encodeParams → intercept → driver`. Throw to block the statement.
+   *
+   * `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' }`.
+   */
+  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>;
+    onActivity?(activity: ClientActivity, ctx: SqlMiddlewareContext): Promise<ActivityInterceptResult | undefined>;
+  };
+  onRow?(row: Record<string, unknown>, plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<void>;
+}
+//#endregion
+//#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/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[];
+}
+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: RuntimeScope, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+}
+/**
+ * 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.
+ *
+ * The two classes are separate so the consumption a plan did not declare is
+ * absent from the value, not merely from its type.
+ */
+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
+/**
+ * Reader of the SQL contract marker. SQL runtimes call `readMarker` before executing user queries (unless `verifyMarker` is false). The adapter owns the full marker-read flow — probing for storage, issuing the read, decoding the row — and returns a tagged result so callers can distinguish "marker storage missing", "no row for this space", and "present".
+ */
+interface MarkerReader {
+  readMarker(queryable: SqlQueryable): Promise<MarkerReadResult>;
+}
+/**
+ * SQL family adapter SPI consumed by `SqlRuntimeBase`. Encapsulates the
+ * runtime contract, marker reader, and plan validation logic so the
+ * runtime can be unit-tested without a concrete SQL adapter profile.
+ *
+ * Implemented by `SqlFamilyAdapter` for production and by mock classes
+ * in tests.
+ */
+interface RuntimeFamilyAdapter<TContract = unknown> {
+  readonly contract: TContract;
+  readonly markerReader: MarkerReader;
+  validatePlan(plan: ExecutionPlan, contract: TContract): void;
+}
+/**
+ * Controls whether the runtime reads and checks the contract marker row on first execute.
+ *
+ * - `'onFirstUse'` (default when omitted): the marker is read once per runtime lifetime, on the
+ *   first `execute()` call. Any hash mismatch or absent marker emits a structured `warn`-level log
+ *   through the runtime's {@link RuntimeLog} and the query proceeds. Subsequent queries skip the
+ *   marker reader entirely.
+ * - `false`: the marker reader is never invoked. No log line is emitted. Use this to opt out of
+ *   the diagnostic entirely (e.g. during a known deploy-skew window).
+ *
+ * The string-or-false shape is forward-compatible: future modes such as `'startup'` (eager check
+ * inside the wrapper `connect()` step) can be added as additive union members without an API break.
+ * `true` is intentionally not permitted — modes are always named.
+ *
+ * Default-on so contract drift surfaces by default — teams who never thought to enable the diagnostic
+ * still see the warning when something goes wrong.
+ */
+type VerifyMarkerOption = 'onFirstUse' | false;
+type TelemetryOutcome = 'success' | 'runtime-error';
+interface RuntimeTelemetryEvent {
+  readonly lane: string;
+  readonly target: string;
+  readonly fingerprint: string;
+  readonly outcome: TelemetryOutcome;
+  readonly durationMs?: number;
+}
+//#endregion
+//#region src/sql-context.d.ts
+/**
+ * Runtime parameterized codec descriptor.
+ *
+ * The unified `CodecDescriptor<P>` shape applied to parameterized codecs — `paramsSchema: StandardSchemaV1<P>` for JSON-boundary validation, `factory: (P) => (CodecInstanceContext) => Codec` for the curried higher-order codec. The factory is called once per distinct `(codecId, typeParams)` of the contract columns; per-instance state lives in the closure.
+ *
+ * Codec-registry-unification spec § Decision.
+ */
+type RuntimeParameterizedCodecDescriptor<P = Record<string, unknown>> = CodecDescriptor<P> & {
+  readonly paramsSchema: NonNullable<CodecDescriptor<P>['paramsSchema']>;
+};
+/**
+ * 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 extends Pick<MutationDefaultGeneratorContributor, 'mutationDefaultGenerators'> {
+  readonly codecs: () => ReadonlyArray<AnyCodecDescriptor>;
+  readonly queryOperations?: () => SqlOperationDescriptors;
+  readonly collectionMethods?: () => ReadonlyArray<CollectionMethodContribution>;
+}
+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 {
+  /**
+   * Codec inferer used by `fns.raw` to look up the codec id for a bare-literal interpolation. Required on every SQL adapter descriptor — the facade reads it off the descriptor at client-construction time without instantiating the runtime adapter.
+   */
+  readonly rawCodecInferer: RawCodecInferer;
+}
+interface SqlRuntimeExtensionDescriptor<TTargetId extends string = string> extends RuntimeExtensionDescriptor<'sql', TTargetId, SqlRuntimeExtensionInstance<TTargetId>>, SqlStaticContributions {
+  create(): SqlRuntimeExtensionInstance<TTargetId>;
+}
+interface SqlExecutionStack<TTargetId extends string = string> {
+  readonly target: SqlRuntimeTargetDescriptor<TTargetId>;
+  readonly adapter: SqlRuntimeAdapterDescriptor<TTargetId>;
+  readonly extensions: readonly SqlRuntimeExtensionDescriptor<TTargetId>[];
+}
+type SqlExecutionStackWithDriver<TTargetId extends string = string> = Omit<ExecutionStack<'sql', TTargetId, SqlRuntimeAdapterInstance<TTargetId>, SqlRuntimeDriverInstance<TTargetId>, SqlRuntimeExtensionInstance<TTargetId>>, 'target' | 'adapter' | 'driver' | 'extensions'> & {
+  readonly target: SqlRuntimeTargetDescriptor<TTargetId>;
+  readonly adapter: SqlRuntimeAdapterDescriptor<TTargetId, SqlRuntimeAdapterInstance<TTargetId>>;
+  readonly driver: RuntimeDriverDescriptor<'sql', TTargetId, unknown, SqlRuntimeDriverInstance<TTargetId>> | undefined;
+  readonly extensions: readonly SqlRuntimeExtensionDescriptor<TTargetId>[];
+};
+interface SqlRuntimeExtensionInstance<TTargetId extends string> extends RuntimeExtensionInstance<'sql', TTargetId> {}
+type SqlRuntimeAdapterInstance<TTargetId extends string = string> = RuntimeAdapterInstance<'sql', TTargetId> & Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
+/**
+ * NOTE: Binding type is intentionally erased to unknown at this shared runtime layer. Target clients (for example `postgres()`) validate and construct the concrete binding before calling `driver.connect(binding)`, which keeps runtime behavior safe today. A future follow-up can preserve TBinding through stack/context generics end-to-end.
+ */
+type SqlRuntimeDriverInstance<TTargetId extends string = string> = RuntimeDriverInstance<'sql', TTargetId> & SqlDriver<unknown>;
+declare function createSqlExecutionStack<TTargetId extends string>(options: {
+  readonly target: SqlRuntimeTargetDescriptor<TTargetId>;
+  readonly adapter: SqlRuntimeAdapterDescriptor<TTargetId>;
+  readonly driver?: RuntimeDriverDescriptor<'sql', TTargetId, unknown, SqlRuntimeDriverInstance<TTargetId>> | undefined;
+  readonly extensions?: readonly SqlRuntimeExtensionDescriptor<TTargetId>[] | undefined;
+}): SqlExecutionStackWithDriver<TTargetId>;
+declare function createExecutionContext<TContract extends Contract<SqlStorage> = Contract<SqlStorage>, TTargetId extends string = string>(options: {
+  readonly contract: TContract;
+  readonly stack: SqlExecutionStack<TTargetId>;
+  /**
+   * Optional driver descriptor. When provided, its `capabilities` are folded into the contract's capability matrix alongside the target, adapter, and extension packs — matching the merge `enrichContract` performs at CLI emit time. The driver is *only* consulted as a capability source here; runtime driver lifecycle is wired separately via {@link instantiateExecutionStack} + `runtime.connect`.
+   */
+  readonly driver?: RuntimeDriverDescriptor<'sql', TTargetId, unknown, SqlRuntimeDriverInstance<TTargetId>>;
+}): ExecutionContext<TContract>;
+//#endregion
+//#region src/sql-runtime.d.ts
+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, and an activity already open when `close()` is called, such as an ORM call, finishes its work: its statements, its transaction and the activities started beneath it are admitted until it ends.
+ */
+type CloseRefusal = 'when-idle' | 'at-once';
+/** How middleware treats a guardrail violation. `'strict'`, the default, makes `budgets` throw on every violation; `'permissive'` lets a violation whose severity is `'warn'` go to `log.warn`. */
+type RuntimeMode = 'strict' | 'permissive';
+interface RuntimeOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
+  readonly context: ExecutionContext<TContract>;
+  readonly adapter: Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
+  readonly driver: SqlDriver<unknown>;
+  readonly verifyMarker?: VerifyMarkerOption;
+  readonly middleware?: readonly SqlMiddleware[];
+  readonly mode?: RuntimeMode;
+  readonly log?: Log$1;
+  readonly closeRefusal?: CloseRefusal | undefined;
+  /** Whether `close()` closes the driver; `true` by default. Pass `false` for a runtime that shares a driver its owner closes: its `close()` refuses new work and waits for work in flight, and leaves the driver open. */
+  readonly ownsDriver?: boolean | undefined;
+}
+/**
+ * SQL-family runtime interface. Named `Runtime` (not `SqlRuntime`) by deliberate exception
+ * to avoid a repo-wide rename; see ADR 230 (runtime target layer) for the recorded decision.
+ */
+interface Runtime extends RuntimeQueryable {
+  connection(): Promise<RuntimeConnection>;
+  telemetry(): RuntimeTelemetryEvent | null;
+  /**
+   * Waits until the runtime has been idle for one turn of the event loop, with no database work in flight and none started since, then closes the driver, unless the runtime was built with `ownsDriver: false`. Runtime-scope work that starts after that, opening a connection included, is refused with `DRIVER.NOT_CONNECTED`. Work on a held connection or transaction is never refused. A statement in flight and a transaction from its start until its commit or rollback settles are work `close()` waits for; a connection held between statements is not, and the driver's close waits for its release. Every call returns the same promise.
+   */
+  close(): Promise<void>;
+  /**
+   * Build a reusable {@link PreparedStatement}. Throws
+   * `RUNTIME.PREPARE_UNUSED_PARAM` if any declared name is unreferenced
+   * by the callback's plan.
+   */
+  prepare<D extends Declaration<CT>, Row, CT extends CodecTypesBase = CodecTypesBase>(declaration: D, callback: PrepareCallback<D, Row>): Promise<PreparedFor<ParamsFromDeclaration<D, CT>, Row>>;
+}
+interface RuntimeConnection extends RuntimeQueryable {
+  transaction(): Promise<RuntimeTransaction>;
+  /**
+   * Returns the connection to the pool for reuse. Only call this when the connection is known to be in a clean state. If a transaction commit/rollback failed or the connection is otherwise suspect, call `destroy(reason)` instead.
+   */
+  release(): Promise<void>;
+  /**
+   * Evicts the connection so it is never reused. Call this when the connection may be in an indeterminate state (e.g. a failed rollback leaving an open transaction, or a broken socket).
+   *
+   * If teardown fails the error is propagated and the connection remains retryable, so the caller can decide whether to swallow the failure or retry cleanup. Calling destroy() or release() more than once after a successful teardown is caller error.
+   *
+   * `reason` is advisory context only. It may be surfaced to driver-level observability hooks (e.g. pg-pool's `'release'` event) but does not influence eviction behavior and is not rethrown.
+   */
+  destroy(reason?: unknown): Promise<void>;
+}
+interface RuntimeTransaction extends RuntimeQueryable {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}
+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
+ * by the target factories, never this class directly.
+ */
+declare abstract class SqlRuntimeBase<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> extends RuntimeCore<SqlQueryPlan, SqlExecutionPlan, SqlMiddleware> implements Runtime {
+  #private;
+  private readonly contract;
+  private readonly adapter;
+  private readonly driver;
+  private readonly familyAdapter;
+  private readonly contractCodecs;
+  private readonly codecDescriptors;
+  private readonly sqlCtx;
+  private readonly verifyMarkerOption;
+  private verifyMarkerPromise;
+  private closePromise;
+  private readonly ownsDriver;
+  private readonly closeRefusal;
+  private codecRegistryValidated;
+  private _telemetry;
+  constructor(options: RuntimeOptions<TContract>);
+  /**
+   * Lower a `SqlQueryPlan` (AST + meta) into a `SqlExecutionPlan`
+   * with encoded parameters ready for the driver.
+   *
+   * Implementation note: SQL splits lower-then-encode across
+   * {@link lowerToDraft} + {@link encodeDraftParams} so the selected
+   * operation's middleware chain can run between them:
+   * {@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.
+   *
+   * `ctx: SqlCodecCallContext` is forwarded to `encodeParams` so
+   * per-query cancellation reaches every codec body during parameter
+   * encoding. SQL params do not populate `ctx.column` — encode-side
+   * column metadata is the middleware's domain.
+   */
+  protected lower(plan: SqlQueryPlan, ctx: SqlCodecCallContext): Promise<SqlExecutionPlan>;
+  /**
+   * AST → pre-encode draft for the selected `query()` or `execute()` operation.
+   * The returned plan has `sql` rendered and `params` populated with the
+   * user-domain values the lowering site collected from `ParamRef` nodes. No
+   * codec encode has happened yet; consumers can mutate `params` via the
+   * `SqlParamRefMutator` before {@link encodeDraftParams} runs.
+   */
+  private lowerToDraft;
+  /**
+   * Encode a draft plan's params for the selected `query()` or `execute()`
+   * operation through the per-column codecs and freeze the result into the
+   * final `SqlExecutionPlan` the driver sees. Errors surface as
+   * `RUNTIME.ENCODE_FAILED` envelopes from {@link encodeParams}.
+   */
+  private encodeDraftParams;
+  /** Default query invocation required by the abstract `RuntimeCore` contract. */
+  protected runDriver(exec: SqlExecutionPlan): AsyncIterable<Record<string, unknown>>;
+  protected runExecute(exec: SqlExecutionPlan): Promise<SqlStatementStats>;
+  /**
+   * 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.
+   */
+  private compilePlan;
+  query<Row>(plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & {
+    readonly _row?: Row;
+  }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  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: HashablePlan, 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 a raw driver connection. SQL issued on it runs below the middleware/codec/telemetry pipeline. It carries its own lifecycle (`release`/`destroy`/`beginTransaction`); the caller owns disposal. It follows the runtime's close rule for connections: see {@link Runtime.close}. Pass the `activityParent` of the activity it is acquired for, so it is admitted after `close()` while that activity is open.
+   */
+  protected acquireRawConnection(options?: Pick<ActivityExecuteOptions, 'activityParent'>): Promise<SqlConnection>;
+  private trackRows;
+  private setupDriverExecution;
+  private beginActivityWork;
+  private warnWhenWaitingOnlyForUnendedWork;
+  private beginOperation;
+  private parentOf;
+  protected getListDecoder(): ListDecoder;
+  private streamDecodedRows;
+  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?: 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?: 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?: 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?: 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, parent: ActivityParent | undefined): Promise<RuntimeTransaction>;
+  private wrapTransaction;
+  telemetry(): RuntimeTelemetryEvent | null;
+  close(): Promise<void>;
+  private closeDriverAfterWork;
+  private refuseAfterWork;
+  private waitForIdleTurn;
+  private ensureCodecRegistryValidated;
+  private verifyMarker;
+  private recordTelemetry;
+}
+/**
+ * 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 & Partial<TransactionStartTarget>>;
+}
+/**
+ * Adds a client's members to the context `withTransaction` passes. The context is the prototype, not spread, so live accessors such as `invalidated` keep reading the transaction's state; spreading would copy their value once.
+ */
+declare function withTransactionMembers<TMembers extends object>(txCtx: TransactionContext, members: TMembers): TransactionContext & TMembers;
+declare function withTransaction<R>(runtime: ConnectionProvider, fn: (tx: TransactionContext) => PromiseLike<R>): Promise<R>;
+//#endregion
+//#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: HashablePlan): Promise<string>;
+}
+/** A prepared statement and the parameters one execution of it binds; its hash is that of the statement it sends with those parameters. The statement is one the SQL runtime prepared, returning rows or statistics. */
+interface BoundPreparedStatement {
+  readonly statement: PreparedStatement<unknown, unknown> | PreparedExecution<unknown>;
+  readonly params: unknown;
+}
+/** What `planContentHash` hashes: a plan, or one execution of a prepared statement, whose hash is that of the statement it sends with those parameters. */
+type HashablePlan = SqlQueryPlan | SqlExecutionPlan | BoundPreparedStatement;
+/** 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 calls `source()` each time it is used, for an object whose source is created later, such as on the first query. */
+declare function lazyActivitySource(source: () => ActivitySource): ActivitySource;
+/** 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: HashablePlan): Promise<string>;
+//#endregion
+//#region ../../../2-sql-family/5-runtime/dist/index.d.mts
+//#region src/codecs/ast-codec-registry.d.ts
+/**
+ * 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.
+ *
+ * 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 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
+//#region src/to-sql.d.ts
+interface RenderedSql {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+}
+interface ToSqlMember {
+  /**
+   * Renders a plan from `sql`, `raw` or the ORM to the SQL and parameters it would run, with no database.
+   *
+   * `params` are the plan's values before codecs encode them for the driver. `beforeCompile` middleware is not applied. A plan with `prepare` bind sites throws `RUNTIME.PREPARE_BIND_ON_ADHOC`, and a plan built for another contract throws `PLAN.HASH_MISMATCH`, as running it would.
+   */
+  toSql(plan: SqlQueryPlan): RenderedSql;
+}
+declare function createToSql<TTargetId extends string>(stack: SqlExecutionStackWithDriver<TTargetId>, contract: Contract<SqlStorage>): ToSqlMember['toSql'];
+//#endregion
+export { SqlExecutionStack as $, validateContractCodecMappings as A, MarkerReader as B, budgets as C, startActivityOn as Ct, lints as D, extractCodecIds as E, ActivitySourceTarget as F, RuntimeConnection as G, PreparedStatementImpl as H, BoundPreparedStatement as I, RuntimeOptions as J, RuntimeFamilyAdapter as K, CloseRefusal as L, ActivityHandle as M, ActivityRoute as N, lowerSqlPlan as O, ActivitySource as P, RuntimeTransaction as Q, ConnectionProvider as R, TransactionEnded as S, planContentHashOn as St, createToSql as T, withTransactionMembers as Tt, PreparedStatementInternals as U, PreparedExecutionImpl as V, Runtime as W, RuntimeQueryable as X, RuntimeParameterizedCodecDescriptor as Y, RuntimeTelemetryEvent as Z, StartActivity$1 as _, delegatingActivitySource as _t, ActivityParent$1 as a, SqlRuntimeBase as at, ToSqlMember as b, findActivitySource as bt, ClientActivityEnd$1 as c, SqlRuntimeExtensionInstance as ct, ClientActivityResult$1 as d, TelemetryOutcome as dt, SqlExecutionStackWithDriver as et, ExecuteInterceptResult$1 as f, TransactionContext as ft, RenderedSql as g, createSqlExecutionStack as gt, QueryInterceptResult$1 as h, createExecutionContext as ht, ActivityInterceptResult$1 as i, SqlRuntimeAdapterInstance as it, ActivityExecuteOptions as j, validateCodecRegistryCompleteness as k, ClientActivityEnded as l, SqlRuntimeTargetDescriptor as lt, Log as m, activitySource as mt, ActivityEndedResult$1 as n, SqlMiddlewareContext as nt, BudgetsOptions as o, SqlRuntimeDriverInstance as ot, LintsOptions as p, VerifyMarkerOption as pt, RuntimeMode as q, ActivityFinalizedResult$1 as r, SqlRuntimeAdapterDescriptor as rt, ClientActivity$1 as s, SqlRuntimeExtensionDescriptor as st, Activity$1 as t, SqlMiddleware as tt, ClientActivityKind$1 as u, SqlStaticContributions as ut, StatementActivity as v, deriveParamMetadata as vt, createAstCodecRegistry as w, withTransaction as wt, TransactionActivity as x, lazyActivitySource as xt, StatementEnded as y, encodeParamsWithMetadata as yt, HashablePlan as z };
+//# sourceMappingURL=index-7nHHQsAj.d.mts.map

package/dist/index-7nHHQsAj.d.mts.map

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