@prisma/orm-family-sql 0.16.0-dev.36

package/dist/index-Bb9U36N4.d.mts

@@ -0,0 +1,511 @@
+import { a as CodecRef$1, n as Codec$1, p as SqlCodecCallContext, s as ContractCodecRegistry } from "./codec-types-MOaceoPi-C5eL2sao.mjs";
+import { c as SqlStorage } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import "./types-BchwQpmO.mjs";
+import { r as SqlOperationDescriptors } from "./index-BgaTJRxj.mjs";
+import { Q as LoweredStatement, Z as LoweredParam, p as AnyQueryAst } from "./types-DIBA80mc-wf5wLmON.mjs";
+import { E as SqlQueryable, _ as SqlDriver, g as SqlConnection, o as MarkerReadResult, t as Adapter } from "./ast-DSuzmsWn.mjs";
+import { a as Expression, i as CodecValue, o as RawCodecInferer, r as CodecTypesBase } from "./expression-DIf8F4Mc.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-CJmsCP7n-DoEpNn7r.mjs";
+import { t as SqlQueryPlan } from "./plan-BTD8xFfa-Dd_K-A1R.mjs";
+import "./plan-Cm4jaoNM.mjs";
+import { n as CodecDescriptorRegistry, r as ExecutionContext } from "./query-lane-context-DtdVMqoz-C2Tj5QHA.mjs";
+import "./query-lane-context-Bz8XJZ45.mjs";
+import { i as SqlParamRefMutator } from "./middleware-B4XbF4d4-tfwBl6mX.mjs";
+import "./middleware-ByRsXxxq.mjs";
+import { y as RuntimeScope } from "./types-Dl20lxky-DC_jdA0T.mjs";
+import "./types-DMxc5KZa.mjs";
+import { Contract, JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
+import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
+import { AfterExecuteResult, AfterExecuteResult as AfterExecuteResult$1, AsyncIterableResult, ExecutionPlan, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeLog as Log, 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-D4zOlprk.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 → beforeExecute → encodeParams → intercept → driver`.
+   *
+   * 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-query `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>;
+  onRow?(row: Record<string, unknown>, plan: SqlExecutionPlan, ctx: SqlMiddlewareContext): Promise<void>;
+  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>;
+}
+//#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[];
+  /**
+   * Run this prepared statement against the given target. The target carries
+   * the execution scope (top-level runtime, an explicit connection, an active
+   * transaction). It is required and explicit — there is no implicit binding
+   * back to the runtime that produced this statement.
+   */
+  execute(target: RuntimeQueryable, 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$1 = 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$1;
+}
+/**
+ * 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<PreparedStatement<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 {
+  /**
+   * Run a prepared statement against this scope. Required for the explicit
+   * `PreparedStatement.execute(target, params)` API — every scope (top-level
+   * runtime, connection, transaction) routes prepared executions through the
+   * `SqlQueryable` it is backed by.
+   */
+  executePrepared<Params, Row>(ps: PreparedStatement<Params, Row>, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+}
+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 runtime
+   * can fire the `beforeExecute` middleware 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.execute`
+   * expects, and is called from the no-middleware fast paths /
+   * fixtures that hit `RuntimeCore`'s default template directly.
+   * `execute()` overrides the template and uses the split form so
+   * `beforeExecute` lands between the two halves.
+   *
+   * `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. 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 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 driver invocation required by the abstract `RuntimeCore` contract. Every production path overrides `execute()` and routes through `executeAgainstQueryable`, so this hook is defensive only — subclasses that delegate back to `super.execute()` would land here.
+   */
+  protected runDriver(exec: SqlExecutionPlan): AsyncIterable<Record<string, unknown>>;
+  /**
+   * 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>;
+  execute<Row>(plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & {
+    readonly _row?: Row;
+  }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  executePrepared<Params, Row>(ps: PreparedStatement<Params, Row>, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  /**
+   * 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 streamRows;
+  /**
+   * Execute a plan against a caller-supplied queryable, running the full
+   * middleware/codec/telemetry pipeline. Use `acquireRawConnection` to obtain a
+   * queryable that subclasses can bind typed plans to.
+   */
+  protected executeAgainstQueryable<Row>(plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>, queryable: SqlQueryable, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  prepare<D extends Declaration<CT>, Row, CT extends CodecTypesBase = CodecTypesBase>(declaration: D, callback: PrepareCallback<D, Row>): Promise<PreparedStatement<ParamsFromDeclaration<D, CT>, Row>>;
+  /**
+   * Execute a prepared statement against a caller-supplied queryable, running
+   * the full middleware/codec/telemetry pipeline.
+   */
+  protected executePreparedAgainstQueryable<P, Row>(ps: PreparedStatementImpl<P, Row>, userParams: Record<string, unknown>, queryable: SqlQueryable, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  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);
+  execute(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+}
+//#endregion
+//#region ../../../2-sql/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
+export { RuntimeQueryable as A, SqlRuntimeDriverInstance as B, PreparedStatementImpl as C, RuntimeFamilyAdapter as D, RuntimeConnection as E, SqlMiddleware as F, TelemetryOutcome as G, SqlRuntimeExtensionInstance as H, SqlMiddlewareContext as I, createExecutionContext as J, TransactionContext as K, SqlRuntimeAdapterDescriptor as L, RuntimeTransaction as M, SqlExecutionStack as N, RuntimeMutationDefaultGenerator as O, SqlExecutionStackWithDriver as P, withTransaction as Q, SqlRuntimeAdapterInstance as R, PreparedStatement as S, Runtime as T, SqlRuntimeTargetDescriptor as U, SqlRuntimeExtensionDescriptor as V, SqlStaticContributions as W, deriveParamMetadata as X, createSqlExecutionStack as Y, encodeParamsWithMetadata as Z, GeneratorStability as _, budgets as a, ParamsFromDeclaration as b, lints as c, validateContractCodecMappings as d, BindSiteParams as f, DeclaredNullable as g, DeclaredCodecId as h, Log as i, RuntimeTelemetryEvent as j, RuntimeParameterizedCodecDescriptor as k, lowerSqlPlan as l, Declaration as m, BudgetsOptions as n, createAstCodecRegistry as o, ConnectionProvider as p, VerifyMarkerOption as q, LintsOptions as r, extractCodecIds as s, AfterExecuteResult$1 as t, validateCodecRegistryCompleteness as u, MarkerReader as v, PreparedStatementInternals as w, PrepareCallback as x, ParamSpec as y, SqlRuntimeBase as z };
+//# sourceMappingURL=index-Bb9U36N4.d.mts.map

package/dist/index-Bb9U36N4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bb9U36N4.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/prepared-statement-D4zOlprk.d.mts","../../../../2-sql/5-runtime/dist/index.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,eAAe,MAAM,kBAAkB,KAAK,sBAAsB,SAAS,mBAAmB,oBAAoB;EAClH,OAAO,KAAK,yBAAyB,MAAM,kBAAkB,KAAK,uBAAuB;EACzF,cAAc,MAAM,kBAAkB,QAAQ,oBAAoB,KAAK,uBAAuB;;;;KAI3F;EACH;EACA;;UAEQ;WACC,SAAS;WACT,QAAQ,oBAAoB;WAC5B,YAAY,oBAAoB;WAChC,gBAAgB;WAChB,aAAa;;;;KAenB,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;;;;;;;EAOzB,QAAQ,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;UAOhG;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,QAAM;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,kBAAkB,sBAAsB,GAAG,KAAK;;UAExL,0BAA0B;EAClC,eAAe,QAAQ;;;;EAIvB,WAAW;;;;;;;;EAQX,QAAQ,mBAAmB;;UAEnB,2BAA2B;EACnC,UAAU;EACV,YAAY;;UAEJ,yBAAyB;;;;;;;EAOjC,gBAAgB,QAAQ,KAAK,IAAI,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;UAE/H,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;;;;;;;;;;;;;;;;;;;;;YAqB1B,MAAM,MAAM,cAAc,KAAK,sBAAsB,QAAQ;;;;;;;;UAQ/D;;;;;;;UAOA;;;;YAIE,UAAU,MAAM,mBAAmB,cAAc;;;;;YAKjD,iBAAiB,MAAM,eAAe,QAAQ;EACxD,QAAQ,KAAK,OAAO,4BAA4B;aACrC,OAAO;KACf,UAAU,wBAAwB,oBAAoB;EACzD,gBAAgB,QAAQ,KAAK,IAAI,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;YAO7H,wBAAwB,QAAQ;UAClC;;;;;;YAME,wBAAwB,KAAK,MAAM,4BAA4B,uBAAuB,WAAW,cAAc,UAAU,wBAAwB,oBAAoB;EAC/K,QAAQ,UAAU,YAAY,KAAK,KAAK,WAAW,iBAAiB,gBAAgB,aAAa,GAAG,UAAU,gBAAgB,GAAG,OAAO,QAAQ,kBAAkB,sBAAsB,GAAG,KAAK;;;;;YAKtL,gCAAgC,GAAG,KAAK,IAAI,sBAAsB,GAAG,MAAM,YAAY,yBAAyB,WAAW,cAAc,UAAU,wBAAwB,oBAAoB;EACzM,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,QAAQ,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;;;;;;;;iBCrazF,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}

package/dist/index-BgaTJRxj.d.mts

@@ -0,0 +1,25 @@
+import { y as QueryOperationTypeEntry } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { OperationDescriptor, OperationDescriptors, OperationRegistry } from "@prisma/orm-framework/operations";
+//#region ../../../2-sql/1-core/operations/dist/index.d.mts
+//#region src/index.d.ts
+interface SqlLoweringSpec {
+  readonly targetFamily: 'sql';
+  readonly strategy: 'infix' | 'function';
+  readonly template: string;
+}
+/**
+ * Runtime shape of a SQL operation entry — tightened beyond the framework's
+ * target-agnostic `OperationEntry` so `impl` returns a codec-exact
+ * `QueryOperationReturn` instead of `unknown`. Consumers (ORM column helper,
+ * sql-builder `fns` dispatch) can read `result.returnType.codecId` without a
+ * cast.
+ */
+type SqlOperationEntry = QueryOperationTypeEntry;
+type SqlOperationDescriptor = OperationDescriptor<SqlOperationEntry>;
+type SqlOperationDescriptors = OperationDescriptors<SqlOperationEntry>;
+type SqlOperationRegistry = OperationRegistry<SqlOperationEntry>;
+declare function createSqlOperationRegistry(): SqlOperationRegistry;
+//#endregion
+export { SqlOperationRegistry as a, SqlOperationEntry as i, SqlOperationDescriptor as n, createSqlOperationRegistry as o, SqlOperationDescriptors as r, SqlLoweringSpec as t };
+//# sourceMappingURL=index-BgaTJRxj.d.mts.map

package/dist/index-BgaTJRxj.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BgaTJRxj.d.mts","names":[],"sources":["../../../../2-sql/1-core/operations/dist/index.d.mts"],"mappings":";;;;;UAGU;WACC;WACA;WACA;;;;;;;;;KASN,oBAAoB;KACpB,yBAAyB,oBAAoB;KAC7C,0BAA0B,qBAAqB;KAC/C,uBAAuB,kBAAkB;iBAC7B,8BAA8B"}

package/dist/index-naming-BZWoh45T.d.mts

@@ -0,0 +1,62 @@
+import { r as IndexInput } from "./sql-index-DsI8HAeK-BJsn-jvD.mjs";
+import { AuthoringWarning, AuthoringWarningSink } from "@prisma/orm-framework/components/authoring";
+//#region ../../../2-sql/1-core/contract/dist/index-naming.d.mts
+//#region src/index-naming.d.ts
+/**
+ * The authored element structure: a fields index carries `columns`, an
+ * expression index carries `expression` — exactly one, never both.
+ */
+type AuthoredIndexElements = {
+  readonly columns: readonly string[];
+  readonly expression?: never;
+} | {
+  readonly columns?: never;
+  readonly expression: string;
+};
+/**
+ * The authored access method: options only exist as options *of a type*, so
+ * the pair is one two-arm union rather than two independent fields. An
+ * options bag without a type is therefore unrepresentable, the same way
+ * {@link AuthoredIndexElements} makes columns-with-expression
+ * unrepresentable.
+ */
+type AuthoredIndexMethod = {
+  readonly type: undefined;
+  readonly options: undefined;
+} | {
+  readonly type: string;
+  readonly options: Record<string, unknown> | undefined;
+};
+/**
+ * An index as authored, before naming: `map` is an exact physical name
+ * (adopted verbatim); `name` is a wire-name prefix. With neither,
+ * the wire prefix defaults to `defaultIndexName(table, columns)`.
+ * `where`, `unique`, `type`, and `options` participate in the content hash
+ * alongside the elements.
+ */
+type AuthoredIndexInput = AuthoredIndexElements & AuthoredIndexMethod & {
+  readonly where: string | undefined;
+  readonly unique: boolean | undefined;
+  readonly map: string | undefined;
+  readonly name: string | undefined;
+};
+/**
+ * Mints the exact-name body-comparison warning for a `map:`-named object
+ * carrying a hand-authorable SQL body — fully formed, so the transport and
+ * the flush stay generic. `subject` is `index` here and `policy` where
+ * policies mint the same warning; the feature name and the remediation are
+ * subject-specific end to end, so a batched summary (grouped on
+ * code + summary) is true of every object it covers.
+ */
+declare function exactNameBodyWarning(subject: 'index' | 'policy', exactName: string): AuthoringWarning;
+/**
+ * Lowers an authored index into the name-identified entity `contract.json`
+ * persists: exact mode adopts `map` verbatim (no prefix, no hash); wire
+ * mode appends the content-hash suffix to the authored or default prefix.
+ * The cross-field guards are the shared enforcement backstop for both
+ * authoring surfaces (PSL pre-empts them with span-anchored diagnostics).
+ */
+declare function lowerAuthoredIndex(tableName: string, authored: AuthoredIndexInput, warnings?: AuthoringWarningSink): IndexInput;
+//#endregion
+export { lowerAuthoredIndex as i, AuthoredIndexMethod as n, exactNameBodyWarning as r, AuthoredIndexInput as t };
+//# sourceMappingURL=index-naming-BZWoh45T.d.mts.map

package/dist/index-naming-BZWoh45T.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-naming-BZWoh45T.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/index-naming.d.mts"],"mappings":";;;;;;;;KAOK;WACM;WACA;;WAEA;WACA;;;;;;;;;KASN;WACM;WACA;;WAEA;WACA,SAAS;;;;;;;;;KASf,qBAAqB,wBAAwB;WACvC;WACA;WACA;WACA;;;;;;;;;;iBAUM,qBAAqB,6BAA6B,oBAAoB;;;;;;;;iBAQtE,mBAAmB,mBAAmB,UAAU,oBAAoB,WAAW,uBAAuB"}