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

package/dist/prepared-statement-9QpkE6JG-C430V3MO.d.mts

@@ -1,529 +0,0 @@
-import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import "./types-UcHa2cTe.mjs";
-import { r as SqlOperationDescriptors } from "./index-C5I8D-MB.mjs";
-import { O as ContractCodecRegistry, Ot as SqlCodecCallContext, T as CodecRef$1, lt as LoweredParam, m as AnyQueryAst, ut as LoweredStatement, x as Codec$1 } from "./types-v3qxLLxo-DCeKv7yY.mjs";
-import { c as SqlQueryable, i as SqlDriver, l as SqlStatementStats, r as SqlConnection } from "./driver-types-BQtRkOJ0-Bv2RPSfr.mjs";
-import { o as MarkerReadResult, t as Adapter } from "./ast-HFcfQZr-.mjs";
-import { t as SqlQueryPlan } from "./plan-CDxduYaN-pLIyyJaB.mjs";
-import { a as CodecValue, i as CodecTypesBase, l as RawCodecInferer, o as Expression, t as AffectedCount } from "./expression-FJK6Ar-d.mjs";
-import { t as SqlExecutionPlan } from "./sql-execution-plan--jKyLpe5-CMGhgO0M.mjs";
-import "./plan-BHLdb0Z7.mjs";
-import { r as ExecutionContext } from "./query-lane-context-Qa-eddrE-kuZ8Z86-.mjs";
-import "./query-lane-context-XMvk7fmY.mjs";
-import { i as SqlParamRefMutator } from "./middleware-AhTz1BOW-th-Suxuf.mjs";
-import "./middleware--TtoxUiW.mjs";
-import { h as RuntimeScope } from "./types-CyxGtOOh-BggSa6Fe.mjs";
-import "./types-B0msOnBM.mjs";
-import { Contract, JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
-import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
-import { AfterExecuteResult, AfterQueryResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, QueryInterceptResult, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware, RuntimeMiddlewareContext } 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-9QpkE6JG.d.mts
-//#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/middleware/sql-middleware.d.ts
-interface SqlMiddlewareContext extends RuntimeMiddlewareContext {
-  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';
-  /**
-   * 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>;
-  /**
-   * 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 → 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.
-   */
-  beforeQuery?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext, params?: SqlParamRefMutator<TCodecMap>): void | Promise<void>;
-  interceptQuery?(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<QueryInterceptResult | 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
-type ColumnRef = {
-  table: string;
-  column: string;
-};
-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/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> {
-  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>;
-}
-/**
- * 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> {
-  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>;
-}
-/**
- * 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.
- *
- * `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.
- */
-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>;
-}
-//#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 `storage.types` instance (or once per inline-`typeParams` column); per-instance state lives in the closure.
- *
- * Codec-registry-unification spec § Decision.
- */
-type RuntimeParameterizedCodecDescriptor<P = Record<string, unknown>> = CodecDescriptor<P>;
-/**
- * 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 {
-  readonly codecs: () => ReadonlyArray<AnyCodecDescriptor>;
-  readonly queryOperations?: () => SqlOperationDescriptors;
-  readonly mutationDefaultGenerators?: () => ReadonlyArray<RuntimeMutationDefaultGenerator>;
-}
-/**
- * Scope across which a generator's value is constant.
- *
- * - `'field'` — one value per defaulting site (one column, one row). Cache strategy: no cache; call per defaulting site. Right for per-row identifiers (UUIDs, CUIDs, ULIDs, nanoid, ksuid).
- * - `'row'` — one value across all defaulting sites of one row of one operation. Cache strategy: per-call cache keyed by `generatorId`. Right for correlation ids stamped into multiple columns of one row.
- * - `'query'` — one value across all rows and columns of one ORM operation. Cache strategy: caller-provided cache keyed by `generatorId`. Right for `timestampNow` (a single timestamp per bulk insert/update).
- */
-type GeneratorStability = 'field' | 'row' | 'query';
-interface RuntimeMutationDefaultGenerator {
-  readonly id: string;
-  readonly generate: (params?: Record<string, unknown>) => unknown;
-  /**
-   * Scope across which the generator's value is constant. The framework derives the cache strategy from this declaration; generator authors never need to know about cache keys. See `GeneratorStability` for the per-value semantics.
-   */
-  readonly stability: GeneratorStability;
-}
-interface SqlRuntimeTargetDescriptor<TTargetId extends string = string, TTargetInstance extends RuntimeTargetInstance<'sql', TTargetId> = RuntimeTargetInstance<'sql', TTargetId>> extends RuntimeTargetDescriptor<'sql', TTargetId, TTargetInstance>, SqlStaticContributions {}
-interface SqlRuntimeAdapterDescriptor<TTargetId extends string = string, TAdapterInstance extends RuntimeAdapterInstance<'sql', TTargetId> = SqlRuntimeAdapterInstance<TTargetId>> extends RuntimeAdapterDescriptor<'sql', TTargetId, TAdapterInstance>, SqlStaticContributions {
-  /**
-   * 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 = RuntimeLog;
-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?: 'strict' | 'permissive';
-  readonly log?: Log;
-}
-/**
- * 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;
-  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;
-}
-/**
- * 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 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 prepareQueryExecution} uses `runBeforeQueryChain` for `query()`,
-   * while {@link prepareExecuteExecution} uses `runBeforeExecuteChain` for
-   * `execute()` (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>;
-  /**
-   * 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.
-   */
-  protected runBeforeCompile(plan: SqlQueryPlan): Promise<SqlQueryPlan>;
-  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>;
-  /**
-   * Returns the raw driver connection. The connection is a `SqlQueryable` — SQL
-   * issued on it runs below the middleware/codec/telemetry pipeline. It carries
-   * its own lifecycle (`release`/`destroy`/`beginTransaction`); the caller owns
-   * disposal.
-   */
-  protected acquireRawConnection(): Promise<SqlConnection>;
-  private setupDriverExecution;
-  private streamRows;
-  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>;
-  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>;
-  /** 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>;
-  connection(): Promise<RuntimeConnection>;
-  private wrapTransaction;
-  telemetry(): RuntimeTelemetryEvent | null;
-  close(): Promise<void>;
-  private ensureCodecRegistryValidated;
-  private verifyMarker;
-  private recordTelemetry;
-}
-/** Minimal structural type `withTransaction` depends on — anything that can open a connection. */
-interface ConnectionProvider {
-  connection(): Promise<RuntimeConnection>;
-}
-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[];
-}
-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>;
-}
-/**
- * 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: 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, RuntimeMutationDefaultGenerator as S, RuntimeTelemetryEvent as T, createSqlExecutionStack as U, VerifyMarkerOption as V, deriveParamMetadata as W, PreparedStatementInternals as _, DeclaredNullable as a, RuntimeConnection as b, ParamSpec as c, PreparedExecution as d, PreparedExecutionImpl as f, PreparedStatementImpl as g, PreparedStatementExecuteTarget as h, DeclaredCodecId as i, SqlRuntimeAdapterDescriptor as j, SqlMiddleware as k, ParamsFromDeclaration as l, PreparedStatement as m, ConnectionProvider as n, GeneratorStability as o, PreparedFor as p, preparedStatementQuery as q, Declaration 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-9QpkE6JG-C430V3MO.d.mts.map

package/dist/prepared-statement-9QpkE6JG-C430V3MO.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepared-statement-9QpkE6JG-C430V3MO.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/prepared-statement-9QpkE6JG.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAaU;WACC,OAAO;WACP;;iBAEM,oBAAoB,KAAK,uBAAuB;iBAChD,yBAAyB,4BAA4B,mBAAmB,iBAAiB,KAAK,qBAAqB,iBAAiB,wBAAwB;;;UAGnK,6BAA6B;WAC5B,UAAU,SAAS;;;;;;UAMpB;WACC,KAAK;WACL,MAAM;;UAEP,cAAc,kBAAkB,0BAA0B,iCAAiC,kBAAkB,kBAAkB,mBAAmB;WACjJ;;;;;;;;;;;;;;;;;;;EAmBT,eAAe,OAAO,WAAW,KAAK,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BrE,aAAa,MAAM,kBAAkB,KAAK,sBAAsB,SAAS,mBAAmB,oBAAoB;EAChH,gBAAgB,MAAM,kBAAkB,KAAK,uBAAuB,QAAQ;EAC5E,OAAO,KAAK,yBAAyB,MAAM,kBAAkB,KAAK,uBAAuB;EACzF,YAAY,MAAM,kBAAkB,QAAQ,kBAAkB,KAAK,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1F,eAAe,MAAM,kBAAkB,KAAK,sBAAsB,SAAS,mBAAmB,oBAAoB;EAClH,kBAAkB,MAAM,kBAAkB,KAAK,uBAAuB,QAAQ;EAC9E,cAAc,MAAM,kBAAkB,QAAQ,oBAAoB,KAAK,uBAAuB;;;;KAI3F;EACH;EACA;;UAEQ;WACC,SAAS;WACT,QAAQ,oBAAoB;WAC5B,YAAY,oBAAoB;WAChC,gBAAgB;WAChB,aAAa;;;;;;;WAOb;;;;KAeN,UAAU,WAAW,iBAAiB,yBAAyB;WACzD,eAAe;WACf,aAAa;WACb;;KAEN,YAAY,WAAW,iBAAiB,kBAAkB,SAAS,eAAe,UAAU;KAC5F,gBAAgB,KAAK,mBAAmB,IAAI;WACtC,eAAe;IACtB;KACC,iBAAiB,KAAK;WAChB;;KAEN,eAAe,iBAAiB,WAAW,IAAI;EAClD,SAAS,gBAAgB,EAAE;EAC3B,UAAU,iBAAiB,EAAE;;KAE1B,sBAAsB,GAAG,WAAW,8BAA8B,WAAW,IAAI,WAAW,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK;KAC3I,gBAAgB,GAAG,QAAQ,QAAQ,eAAe,OAAO,aAAa;UACjE,kBAAkB,QAAQ;WACzB;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,UAAU;WACV,OAAO;EAChB,MAAM,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;;UAQ9F,kBAAkB;WACjB;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,UAAU;EACnB,QAAQ,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;;;;;;;;;;;;;;;KAkBzF,YAAY,QAAQ,QAAQ,uBAAuB,kBAAkB,QAAQ,QAAQ,cAAc,iBAAiB,kBAAkB,UAAU,kBAAkB,QAAQ;;;cAGjK;UACJ,uCAAuC;GAC9C,0BAA0B,QAAQ,WAAW,kBAAkB,SAAS,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;cAIvH;UACJ,qCAAqC;GAC5C,wBAAwB,QAAQ,KAAK,WAAW,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;UAO/I;EACR,WAAW,WAAW,eAAe,QAAQ;;;;;;;;;;UAUrC,qBAAqB;WACpB,UAAU;WACV,cAAc;EACvB,aAAa,MAAM,eAAe,UAAU;;;;;;;;;;;;;;;;;;;KAmBzC;KACA;UACK;WACC;WACA;WACA;WACA,SAAS;WACT;;;;;;;;;;;KAWN,oCAAoC,IAAI,2BAA2B,gBAAgB;;;;UAI9E;WACC,cAAc,cAAc;WAC5B,wBAAwB;WACxB,kCAAkC,cAAc;;;;;;;;;KAStD;UACK;WACC;WACA,WAAW,SAAS;;;;WAIpB,WAAW;;UAEZ,2BAA2B,mCAAmC,wBAAwB,6BAA6B,aAAa,6BAA6B,oBAAoB,+BAA+B,WAAW,kBAAkB;UAC7O,4BAA4B,mCAAmC,yBAAyB,8BAA8B,aAAa,0BAA0B,oBAAoB,gCAAgC,WAAW,mBAAmB;;;;WAI9O,iBAAiB;;UAElB,8BAA8B,2CAA2C,kCAAkC,WAAW,4BAA4B,aAAa;EACvK,UAAU,4BAA4B;;UAE9B,kBAAkB;WACjB,QAAQ,2BAA2B;WACnC,SAAS,4BAA4B;WACrC,qBAAqB,8BAA8B;;KAEzD,4BAA4B,qCAAqC,KAAK,sBAAsB,WAAW,0BAA0B,YAAY,yBAAyB,YAAY,4BAA4B;WACxM,QAAQ,2BAA2B;WACnC,SAAS,4BAA4B,WAAW,0BAA0B;WAC1E,QAAQ,+BAA+B,oBAAoB,yBAAyB;WACpF,qBAAqB,8BAA8B;;UAEpD,4BAA4B,kCAAkC,gCAAgC;KACnG,0BAA0B,qCAAqC,8BAA8B,aAAa,QAAQ,aAAa,SAAS,aAAa;;;;KAIrJ,yBAAyB,qCAAqC,6BAA6B,aAAa;iBAC5F,wBAAwB,0BAA0B;WACxD,QAAQ,2BAA2B;WACnC,SAAS,4BAA4B;WACrC,SAAS,+BAA+B,oBAAoB,yBAAyB;WACrF,sBAAsB,8BAA8B;IAC3D,4BAA4B;iBACf,uBAAuB,kBAAkB,SAAS,cAAc,SAAS,aAAa,mCAAmC;WAC/H,UAAU;WACV,OAAO,kBAAkB;;;;WAIzB,SAAS,+BAA+B,oBAAoB,yBAAyB;IAC5F,iBAAiB;;;KAGhB,MAAM;UACD,eAAe,kBAAkB,SAAS,cAAc,SAAS;WAChE,SAAS,iBAAiB;WAC1B,SAAS,QAAQ,aAAa,SAAS,aAAa;WACpD,QAAQ;WACR,eAAe;WACf,sBAAsB;WACtB;WACA,MAAM;;;;;;UAMP,gBAAgB;EACxB,cAAc,QAAQ;EACtB,aAAa;EACb,SAAS;;;;;;EAMT,QAAQ,UAAU,YAAY,KAAK,KAAK,WAAW,iBAAiB,gBAAgB,aAAa,GAAG,UAAU,gBAAgB,GAAG,OAAO,QAAQ,YAAY,sBAAsB,GAAG,KAAK;;UAElL,0BAA0B;EAClC,eAAe,QAAQ;;;;EAIvB,WAAW;;;;;;;;EAQX,QAAQ,mBAAmB;;UAEnB,2BAA2B;EACnC,UAAU;EACV,YAAY;;UAEJ,yBAAyB;UACzB,2BAA2B;WAC1B;;;;;;;uBAOY,eAAe,kBAAkB,SAAS,cAAc,SAAS,qBAAqB,YAAY,cAAc,kBAAkB,0BAA0B;;mBAEhK;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;UACT;UACA;UACA;EACR,YAAY,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;YAoB1B,MAAM,MAAM,cAAc,KAAK,sBAAsB,QAAQ;;;;;;;;UAQ/D;;;;;;;UAOA;;YAEE,UAAU,MAAM,mBAAmB,cAAc;YACjD,WAAW,MAAM,mBAAmB,QAAQ;;;;;YAK5C,iBAAiB,MAAM,eAAe,QAAQ;UAChD;EACR,MAAM,KAAK,OAAO,4BAA4B;aACnC,OAAO;KACf,UAAU,wBAAwB,oBAAoB;EACzD,QAAQ,MAAM,4BAA4B,uBAAuB,UAAU,wBAAwB,QAAQ;GAC1G,wBAAwB,QAAQ,KAAK,IAAI,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;GAC/I,0BAA0B,QAAQ,IAAI,kBAAkB,SAAS,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;;;;YAOlH,wBAAwB,QAAQ;UAClC;UACA;UACA;UACA;UACA;UACA;;YAEE,sBAAsB,KAAK,MAAM,4BAA4B,uBAAuB,WAAW,cAAc,UAAU,wBAAwB,oBAAoB;;YAEnK,kCAAkC,MAAM,4BAA4B,uBAAuB,WAAW,cAAc,UAAU,wBAAwB,QAAQ;EACxK,QAAQ,UAAU,YAAY,KAAK,KAAK,WAAW,iBAAiB,gBAAgB,aAAa,GAAG,UAAU,gBAAgB,GAAG,OAAO,QAAQ,YAAY,sBAAsB,GAAG,KAAK;;YAEhL,iCAAiC,GAAG,KAAK,IAAI,sBAAsB,GAAG,MAAM,qBAAqB,WAAW,cAAc,UAAU,wBAAwB,oBAAoB;;YAEhL,mCAAmC,GAAG,IAAI,sBAAsB,IAAI,qBAAqB,WAAW,cAAc,UAAU,wBAAwB,QAAQ;EACtK,cAAc,QAAQ;UACd;EACR,aAAa;EACb,SAAS;UACD;UACA;UACA;;;UAGA;EACR,cAAc,QAAQ;;iBAEP,gBAAgB,GAAG,SAAS,oBAAoB,KAAK,IAAI,uBAAuB,YAAY,KAAK,QAAQ;;;UAGhH;WACC;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,eAAe;WACf,wBAAwB;;cAErB,sBAAsB,QAAQ,gBAAgB,kBAAkB,QAAQ,MAAM;WACjF;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,eAAe;WACf,wBAAwB;EACjC,YAAY,WAAW;EACvB,MAAM,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;;;;cAU1F,sBAAsB,mBAAmB,kBAAkB,SAAS;WACvE;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,eAAe;WACf,wBAAwB;EACjC,YAAY,WAAW;EACvB,QAAQ,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ"}