@prisma-next/sql-relational-core 0.5.0-dev.9 → 0.5.1

package/README.md

@@ -89,37 +89,71 @@ flowchart TD
 
 ### Plan Helpers (`plan.ts`)
 - Defines `SqlQueryPlan<Row>` interface for SQL query plans produced by lanes before lowering
-- Provides `augmentDescriptorWithColumnMeta(descriptors, columnMeta)` helper to update ParamDescriptor with `codecId` and `nativeType` from column metadata
+- Per [ADR 205](../../../../docs/architecture%20docs/adrs/ADR%20205%20-%20Execution%20metadata%20lives%20on%20AST.md), codec IDs travel on `ProjectionItem.codecId` (output) and `ParamRef.codecId` (parameters) on the AST itself, not on plan-level descriptor lists
 
-### Codec Factory (`ast/codec-types.ts` via `exports/ast.ts`)
+### Codec authoring (class form)
 
-- `codec({...})` is the SQL-side factory for constructing `Codec` values. It accepts `encode` and `decode` author functions in **either sync or async form** with no annotations; the constructed codec exposes Promise-returning query-time methods regardless of which form was used. `encode` may be omitted (identity default); `decode` is required.
-- Build-time methods (`encodeJson`, `decodeJson`, `renderOutputType?`) are synchronous and pass through unchanged.
-- This is the only public entry point for SQL codecs. There is no separate `codecSync` / `codecAsync` factory and no per-codec async marker on the resulting value.
+Codec authors extend the framework `CodecImpl` (and pair the codec with a `CodecDescriptorImpl` registration) per [ADR 208 — Higher-order codecs for parameterized types](../../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md). Each codec class declares the four conversion methods (`encode`, `decode`, `encodeJson`, `decodeJson`); the descriptor class declares static metadata (`codecId`, `traits`, `targetTypes`, `meta`, `paramsSchema`, optional `renderOutputType`) and a `factory` returning a per-instance codec.
+
+- Query-time methods (`encode` / `decode`) are typed as `Promise<…>`-returning at the public boundary; sync method bodies are accepted via TypeScript bivariance and the runtime always awaits.
+- Build-time methods (`encodeJson` / `decodeJson` / `renderOutputType?`) stay synchronous so contract validation and client construction stay synchronous.
+- Both `encode` and `decode` must be implemented — there is no identity-default fallback.
+
+```ts
+// Non-parameterized codec (P = void) — see packages/3-targets/3-targets/postgres/src/core/codecs.ts
+// for the production form.
+import {
+  CodecDescriptorImpl,
+  CodecImpl,
+  voidParamsSchema,
+  type CodecCallContext,
+  type CodecInstanceContext,
+} from '@prisma-next/framework-components/codec';
+
+class PgTextCodec extends CodecImpl<'pg/text@1', readonly ['equality'], string, string> {
+  override readonly id = 'pg/text@1';
+  override readonly traits = ['equality'] as const;
+  encode(v: string, _ctx: CodecCallContext): Promise<string> { return Promise.resolve(v); }
+  decode(w: string, _ctx: CodecCallContext): Promise<string> { return Promise.resolve(w); }
+  encodeJson(v: string) { return v; }
+  decodeJson(j: unknown) { return j as string; }
+}
+
+class PgTextDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = 'pg/text@1';
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly paramsSchema = voidParamsSchema;
+  override readonly factory = () => (_ctx: CodecInstanceContext) => new PgTextCodec();
+}
+```
+
+#### Codec call context (`ctx`)
+
+Codecs receive a second `ctx` options argument; you may ignore it. The runtime allocates one `SqlCodecCallContext` per `runtime.execute(plan, { signal })` call and threads the same reference to every codec dispatch site as a non-optional argument — when no `signal` is supplied the runtime still threads an empty `{}`, never `undefined`. The internal `Codec` interface declares the parameter as required (`encode(value, ctx: SqlCodecCallContext)` / `decode(wire, ctx: SqlCodecCallContext)`); single-arg method bodies continue to compile via TypeScript's bivariance for trailing parameters, so codec ergonomics are unchanged.
+
+- **`ctx.signal`** — the same `AbortSignal` reference at every codec call in one execute. Forward it to network SDKs so aborted queries stop talking to the underlying service.
+- **`ctx.column`** (decode-side only) — `{ table, name }` for cells the runtime can resolve to a single column ref; `undefined` for aggregate aliases, computed projections, and other unresolvable cells. Encode-side `ctx.column` is always `undefined` (encode-time column enrichment is the middleware's domain).
 
 ```ts
-// Sync authoring:
-const textCodec = codec({
-  typeId: 'pg/text@1',
-  targetTypes: ['text'],
-  encode: (v: string) => v,
-  decode: (w: string) => w,
-  encodeJson: (v: string) => v,
-  decodeJson: (j: string) => j as string,
-});
-
-// Async authoring (e.g. KMS-backed encryption): same factory, same shape.
-const secretCodec = codec({
-  typeId: 'pg/secret@1',
-  targetTypes: ['text'],
-  encode: async (v: string) => encrypt(v, await getKey()),
-  decode: async (w: string) => decrypt(w, await getKey()),
-  encodeJson: (v: string) => v,
-  decodeJson: (j: string) => j as string,
-});
+// Forward ctx.signal to a network call so aborted queries stop the SDK.
+class PgKmsSecretCodec extends CodecImpl<'pg/kms-secret@1', readonly [], string, string> {
+  override readonly id = 'pg/kms-secret@1';
+  override readonly traits = [] as const;
+  override async encode(v: string, ctx: SqlCodecCallContext): Promise<string> {
+    return kms.encrypt({ plaintext: v }, { signal: ctx.signal });
+  }
+  override async decode(w: string, ctx: SqlCodecCallContext): Promise<string> {
+    return kms.decrypt({ ciphertext: w }, { signal: ctx.signal });
+  }
+  encodeJson(v: string) { return v; }
+  decodeJson(j: unknown) { return j as string; }
+}
 ```
 
-See [ADR 204 — Single-Path Async Codec Runtime](../../../../docs/architecture%20docs/adrs/ADR%20204%20-%20Single-Path%20Async%20Codec%20Runtime.md).
+Codec bodies that ignore `ctx.signal` complete in the background (cooperative cancellation); aborts still surface to the caller as `RUNTIME.ABORTED` with `details.phase ∈ { 'encode', 'decode', 'stream' }`.
+
+See [ADR 204 — Single-Path Async Codec Runtime](../../../../docs/architecture%20docs/adrs/ADR%20204%20-%20Single-Path%20Async%20Codec%20Runtime.md) and [ADR 207 — Codec call context: per-query `AbortSignal` and column metadata](../../../../docs/architecture%20docs/adrs/ADR%20207%20-%20Codec%20call%20context%20per-query%20AbortSignal%20and%20column%20metadata.md).
 
 ### AST Surface (`ast/*` via `exports/ast.ts`)
 - Query roots: `SelectAst`, `InsertAst`, `UpdateAst`, `DeleteAst`

package/dist/codec-types-BUfBna4G.d.mts

@@ -0,0 +1,107 @@
+import { Codec, CodecCallContext, CodecCallContext as CodecCallContext$1, CodecDescriptor, CodecDescriptor as CodecDescriptor$1, CodecInstanceContext, CodecTrait, CodecTrait as CodecTrait$1 } from "@prisma-next/framework-components/codec";
+
+//#region src/ast/codec-types.d.ts
+/**
+ * SQL-family addressing of a single column. The decode site populates a `SqlColumnRef` whenever it can resolve the cell to a single underlying `(table, column)` (the typical case for projected columns from a single-table source); cells the runtime cannot resolve (aggregate aliases, include aggregate fields, computed projections without a simple ref) get `column = undefined`.
+ *
+ * The shape is a structural projection of the runtime's `ColumnRef` so the SQL decode site can reuse the resolution it already performs for `RUNTIME.DECODE_FAILED` envelope construction without allocating twice per cell.
+ */
+interface SqlColumnRef {
+  readonly table: string;
+  readonly name: string;
+}
+/**
+ * SQL-family per-call context. Extends the framework {@link CodecCallContext} (which carries `signal` only) with `column?: SqlColumnRef`, populated on **decode** call sites that can resolve a single underlying column ref. Encode call sites currently leave `column` undefined (encode-time column context is the middleware's domain).
+ *
+ * SQL codec authors writing codec methods observe this type via {@link SqlCodec}. The framework codec dispatch surface (and Mongo) sees only the base `CodecCallContext`.
+ */
+interface SqlCodecCallContext extends CodecCallContext {
+  readonly column?: SqlColumnRef;
+}
+/**
+ * SQL-family per-instance context. Extends the framework {@link CodecInstanceContext} (`name` only) with `usedAt`, the set of `(table, column)` pairs the resolved codec serves.
+ *
+ * - For `typeRef` columns sharing one named `storage.types` instance, the array lists every referencing column — a column-scoped stateful codec (e.g. encryption) can derive aggregated per-instance state across all the columns sharing the named instance.
+ * - For inline-`typeParams` columns, the array has exactly one entry — the column that owns the inline params.
+ * - For shared non-parameterized codecs, the array carries one representative entry (the column that triggered materialization); the codec is shared across every column with that codec id, so the `usedAt` is informational only.
+ *
+ * SQL extensions consuming `usedAt` (e.g. column-scoped state derivation) type their factory parameter as `SqlCodecInstanceContext`. Extensions that don't read `usedAt` type their factory parameter as the family-agnostic {@link CodecInstanceContext} — a `SqlCodecInstanceContext` is structurally assignable to the base.
+ */
+interface SqlCodecInstanceContext extends CodecInstanceContext {
+  readonly usedAt: ReadonlyArray<{
+    readonly table: string;
+    readonly column: string;
+  }>;
+}
+/**
+ * Codec metadata for database-specific type information. Used for schema introspection and verification.
+ */
+interface CodecMeta {
+  readonly db?: {
+    readonly sql?: {
+      readonly postgres?: {
+        readonly nativeType: string;
+      };
+    };
+  };
+}
+/**
+ * SQL codec — extends the framework codec base by narrowing the per-call context to the SQL-family {@link SqlCodecCallContext} (adds `column?: SqlColumnRef`). TypeScript treats method-syntax declarations bivariantly, so the SQL narrowing is structurally compatible with the framework {@link BaseCodec} super-interface.
+ *
+ * Codec-id-keyed static metadata (`traits`, `targetTypes`, `meta`, `paramsSchema`, `renderOutputType`) lives on the unified {@link import('@prisma-next/framework-components/codec').CodecDescriptor} — the codec instance itself only carries `id` plus the four conversion methods.
+ *
+ * See `Codec` in `@prisma-next/framework-components/codec` for the codec contract that this interface extends.
+ */
+interface Codec$1<Id extends string = string, TTraits extends readonly CodecTrait[] = readonly CodecTrait[], TWire = unknown, TInput = unknown> extends Codec<Id, TTraits, TWire, TInput> {
+  encode(value: TInput, ctx: SqlCodecCallContext): Promise<TWire>;
+  decode(wire: TWire, ctx: SqlCodecCallContext): Promise<TInput>;
+}
+/**
+ * Contract-bound codec registry.
+ *
+ * The dispatch interface for encode/decode at runtime: built once at `ExecutionContext` construction time by walking the contract's `storage.tables[].columns[]` and resolving each column through its descriptor's factory (per-instance for parameterized columns; the cached shared codec for non-parameterized columns). The dispatch path calls `forColumn(table, column).encode/decode(...)` and doesn't know whether the codec
+ * is parameterized.
+ *
+ * `forCodecId(codecId)` is the refs-less fallback. Every column-bound `ParamRef` carries `refs: { table; column }` and the builder-pipeline `validateParamRefRefs` pass enforces refs on every parameterized `ParamRef` before encode runs, so this fallback is only reached for non-parameterized codec ids.
+ */
+interface ContractCodecRegistry {
+  /**
+   * Resolve the codec for `(table, column)`. Returns the per-instance parameterized codec for parameterized columns, the shared codec for non-parameterized columns, or `undefined` if the column is unknown or the codec isn't registered.
+   */
+  forColumn(table: string, column: string): Codec$1 | undefined;
+  /**
+   * Resolve a codec by id. For non-parameterized codecs this returns the canonical shared instance materialized once at context construction; for parameterized codecs it returns the column-resolved instance when a single column declares the codec id, or the `factory(undefined)` representative when the descriptor's factory is parameter-tolerant. Used by refs-less call sites; the validator pass guarantees the call site's
+   * `codecId` is non-parameterized (or parameter-tolerant) at this boundary.
+   */
+  forCodecId(codecId: string): Codec$1 | undefined;
+}
+/**
+ * Variance-erased descriptor type used for heterogeneous storage in collection containers and on the unified contributor `codecs:` slot. The descriptor's `factory` and `renderOutputType` are contravariant in `P`, so descriptors with different params shapes are not in a subtype relationship; collecting them into one container needs an explicit variance erasure rather than `CodecDescriptor<unknown>` (which is the
+ * narrowest, not the widest, of the family).
+ */
+type AnyCodecDescriptor = CodecDescriptor<any>;
+type DescriptorResolvedCodec<D> = D extends CodecDescriptor<infer _P> ? ReturnType<ReturnType<D['factory']>> : never;
+type DescriptorCodecId<D> = D extends AnyCodecDescriptor ? D['codecId'] : never;
+type DescriptorCodecInput<D> = DescriptorResolvedCodec<D> extends Codec<string, readonly CodecTrait[], unknown, infer In> ? In : never;
+/**
+ * Resolve the trait union for a descriptor `D`.
+ *
+ * Reads `traits` directly off the descriptor — concrete descriptor classes declare `override readonly traits = [...] as const`, which preserves the literal trait tuple at the descriptor type. Reading from the resolved codec instance (`CodecImpl<…, TTraits, …>`) would lose the literal because `Codec` carries `TTraits` only on its optional phantom slot (`readonly __codecTraits?: TTraits`); codecs extending `CodecImpl`
+ * have no required structural site that pins `TTraits`, so a descriptor-keyed extractor reading from the codec instance would widen to the broad `CodecTrait` union.
+ */
+type DescriptorCodecTraits<D> = D extends {
+  readonly traits: infer TTraits extends readonly CodecTrait[];
+} ? TTraits[number] & CodecTrait : never;
+/**
+ * Project a record of {@link AnyCodecDescriptor}s keyed by scalar name onto the codec-id-keyed `CodecTypes` shape consumed by emit and no-emit type pipelines (`{ readonly [codecId]: { input; output; traits } }`).
+ *
+ * Canonical extractor for the descriptor-keyed type pipeline; the legacy instance-keyed extractor and its `mkCodec`-bound builder retired alongside the carrier deletion.
+ */
+type ExtractCodecTypes<ScalarNames extends { readonly [K in keyof ScalarNames]: AnyCodecDescriptor } = Record<never, never>> = { readonly [K in keyof ScalarNames as DescriptorCodecId<ScalarNames[K]>]: {
+  readonly input: DescriptorCodecInput<ScalarNames[K]>;
+  readonly output: DescriptorCodecInput<ScalarNames[K]>;
+  readonly traits: DescriptorCodecTraits<ScalarNames[K]>;
+} };
+//#endregion
+export { CodecMeta as a, DescriptorCodecId as c, ExtractCodecTypes as d, SqlCodecCallContext as f, CodecDescriptor$1 as i, DescriptorCodecInput as l, SqlColumnRef as m, Codec$1 as n, CodecTrait$1 as o, SqlCodecInstanceContext as p, CodecCallContext$1 as r, ContractCodecRegistry as s, AnyCodecDescriptor as t, DescriptorCodecTraits as u };
+//# sourceMappingURL=codec-types-BUfBna4G.d.mts.map

package/dist/codec-types-BUfBna4G.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-BUfBna4G.d.mts","names":[],"sources":["../src/ast/codec-types.ts"],"mappings":";;;;AAmBA;;;;UAAiB,YAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA;AAAA;;;;;;UAQM,mBAAA,SAA4B,gBAAA;EAAA,SAClC,MAAA,GAAS,YAAA;AAAA;;;;;;;;;;UAYH,uBAAA,SAAgC,oBAAA;EAAA,SACtC,MAAA,EAAQ,aAAA;IAAA,SAAyB,KAAA;IAAA,SAAwB,MAAA;EAAA;AAAA;;;;UAMnD,SAAA;EAAA,SACN,EAAA;IAAA,SACE,GAAA;MAAA,SACE,QAAA;QAAA,SACE,UAAA;MAAA;IAAA;EAAA;AAAA;;;;;;;;UAaA,OAAA,sDAEU,UAAA,cAAwB,UAAA,+CAGzC,KAAA,CAAU,EAAA,EAAI,OAAA,EAAS,KAAA,EAAO,MAAA;EACtC,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,mBAAA,GAAsB,OAAA,CAAQ,KAAA;EACzD,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,mBAAA,GAAsB,OAAA,CAAQ,MAAA;AAAA;;;;;;;;;UAWxC,qBAAA;EAbO;;;EAiBtB,SAAA,CAAU,KAAA,UAAe,MAAA,WAAiB,OAAA;EAhB5B;;;;EAsBd,UAAA,CAAW,OAAA,WAAkB,OAAA;AAAA;;;;;KAQnB,kBAAA,GAAqB,eAAA;AAAA,KAE5B,uBAAA,MACH,CAAA,SAAU,eAAA,aAA4B,UAAA,CAAW,UAAA,CAAW,CAAA;AAAA,KAElD,iBAAA,MAAuB,CAAA,SAAU,kBAAA,GAAqB,CAAA;AAAA,KAEtD,oBAAA,MACV,uBAAA,CAAwB,CAAA,UAAW,KAAA,kBAA2B,UAAA,yBAC1D,EAAA;;AA3BN;;;;;KAoCY,qBAAA,MAA2B,CAAA;EAAA,SAC5B,MAAA,iCAAuC,UAAA;AAAA,IAE9C,OAAA,WAAkB,UAAA;;;;;;KAQV,iBAAA,4CAEa,WAAA,GAAc,kBAAA,KACjC,MAAA,yCAEiB,WAAA,IAAe,iBAAA,CAAkB,WAAA,CAAY,CAAA;EAAA,SACvD,KAAA,EAAO,oBAAA,CAAqB,WAAA,CAAY,CAAA;EAAA,SACxC,MAAA,EAAQ,oBAAA,CAAqB,WAAA,CAAY,CAAA;EAAA,SACzC,MAAA,EAAQ,qBAAA,CAAsB,WAAA,CAAY,CAAA;AAAA"}

package/dist/{errors-D3xmG4h-.mjs → errors-BF7W5uUd.mjs}

@@ -29,7 +29,7 @@ function planUnsupported(message, details, hints, docs) {
 		docs
 	});
 }
-
 //#endregion
 export { planUnsupported as n, planInvalid as t };
-//# sourceMappingURL=errors-D3xmG4h-.mjs.map
+
+//# sourceMappingURL=errors-BF7W5uUd.mjs.map

package/dist/{errors-D3xmG4h-.mjs.map → errors-BF7W5uUd.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"errors-D3xmG4h-.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import type { RuntimeError } from './types';\n\nexport function planInvalid(\n  message: string,\n  details?: Record<string, unknown>,\n  hints?: readonly string[],\n  docs?: readonly string[],\n): RuntimeError {\n  const error = new Error(message) as RuntimeError;\n\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n\n  return Object.assign(error, {\n    code: 'PLAN.INVALID',\n    category: 'PLAN' as const,\n    severity: 'error' as const,\n    details,\n    hints,\n    docs,\n  });\n}\n\nexport function planUnsupported(\n  message: string,\n  details?: Record<string, unknown>,\n  hints?: readonly string[],\n  docs?: readonly string[],\n): RuntimeError {\n  const error = new Error(message) as RuntimeError;\n\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n\n  return Object.assign(error, {\n    code: 'PLAN.UNSUPPORTED',\n    category: 'PLAN' as const,\n    severity: 'error' as const,\n    details,\n    hints,\n    docs,\n  });\n}\n"],"mappings":";AAEA,SAAgB,YACd,SACA,SACA,OACA,MACc;CACd,MAAM,QAAQ,IAAI,MAAM,QAAQ;AAEhC,QAAO,eAAe,OAAO,QAAQ;EACnC,OAAO;EACP,cAAc;EACf,CAAC;AAEF,QAAO,OAAO,OAAO,OAAO;EAC1B,MAAM;EACN,UAAU;EACV,UAAU;EACV;EACA;EACA;EACD,CAAC;;AAGJ,SAAgB,gBACd,SACA,SACA,OACA,MACc;CACd,MAAM,QAAQ,IAAI,MAAM,QAAQ;AAEhC,QAAO,eAAe,OAAO,QAAQ;EACnC,OAAO;EACP,cAAc;EACf,CAAC;AAEF,QAAO,OAAO,OAAO,OAAO;EAC1B,MAAM;EACN,UAAU;EACV,UAAU;EACV;EACA;EACA;EACD,CAAC"}
+{"version":3,"file":"errors-BF7W5uUd.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import type { RuntimeError } from './types';\n\nexport function planInvalid(\n  message: string,\n  details?: Record<string, unknown>,\n  hints?: readonly string[],\n  docs?: readonly string[],\n): RuntimeError {\n  const error = new Error(message) as RuntimeError;\n\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n\n  return Object.assign(error, {\n    code: 'PLAN.INVALID',\n    category: 'PLAN' as const,\n    severity: 'error' as const,\n    details,\n    hints,\n    docs,\n  });\n}\n\nexport function planUnsupported(\n  message: string,\n  details?: Record<string, unknown>,\n  hints?: readonly string[],\n  docs?: readonly string[],\n): RuntimeError {\n  const error = new Error(message) as RuntimeError;\n\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n\n  return Object.assign(error, {\n    code: 'PLAN.UNSUPPORTED',\n    category: 'PLAN' as const,\n    severity: 'error' as const,\n    details,\n    hints,\n    docs,\n  });\n}\n"],"mappings":";AAEA,SAAgB,YACd,SACA,SACA,OACA,MACc;CACd,MAAM,QAAQ,IAAI,MAAM,QAAQ;CAEhC,OAAO,eAAe,OAAO,QAAQ;EACnC,OAAO;EACP,cAAc;EACf,CAAC;CAEF,OAAO,OAAO,OAAO,OAAO;EAC1B,MAAM;EACN,UAAU;EACV,UAAU;EACV;EACA;EACA;EACD,CAAC;;AAGJ,SAAgB,gBACd,SACA,SACA,OACA,MACc;CACd,MAAM,QAAQ,IAAI,MAAM,QAAQ;CAEhC,OAAO,eAAe,OAAO,QAAQ;EACnC,OAAO;EACP,cAAc;EACf,CAAC;CAEF,OAAO,OAAO,OAAO,OAAO;EAC1B,MAAM;EACN,UAAU;EACV,UAAU;EACV;EACA;EACA;EACD,CAAC"}

package/dist/{errors-CDvhnH7P.d.mts → errors-BgNpVAT8.d.mts}

@@ -1,8 +1,8 @@
-import { y as RuntimeError } from "./types-CG3u534i.mjs";
+import { y as RuntimeError } from "./types-D6Pk1DTr.mjs";
 
 //#region src/errors.d.ts
 declare function planInvalid(message: string, details?: Record<string, unknown>, hints?: readonly string[], docs?: readonly string[]): RuntimeError;
 declare function planUnsupported(message: string, details?: Record<string, unknown>, hints?: readonly string[], docs?: readonly string[]): RuntimeError;
 //#endregion
 export { planUnsupported as n, planInvalid as t };
-//# sourceMappingURL=errors-CDvhnH7P.d.mts.map
+//# sourceMappingURL=errors-BgNpVAT8.d.mts.map

package/dist/errors-BgNpVAT8.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-BgNpVAT8.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;iBAEgB,WAAA,CACd,OAAA,UACA,OAAA,GAAU,MAAA,mBACV,KAAA,sBACA,IAAA,uBACC,YAAA;AAAA,iBAkBa,eAAA,CACd,OAAA,UACA,OAAA,GAAU,MAAA,mBACV,KAAA,sBACA,IAAA,uBACC,YAAA"}

package/dist/exports/ast.d.mts

@@ -1,46 +1,11 @@
-import { a as CodecMeta, c as CodecTrait, d as ExtractDataTypes, f as codec, i as CodecInput, l as CodecTraits, m as defineCodecs, n as CodecDefBuilder, o as CodecParamsDescriptor, p as createCodecRegistry, r as CodecId, s as CodecRegistry, t as Codec, u as ExtractCodecTypes } from "../codec-types-B2Xdq0Wr.mjs";
-import { $ as ToWhereExpr, A as InsertOnConflict, B as NotExpr, C as ExistsExpr, D as ExpressionSource, E as ExpressionRewriter, F as JsonObjectEntry, G as ParamRef, H as OperationExpr, I as JsonObjectExpr, J as SelectAst, K as ProjectionExpr, L as ListExpression, M as JoinAst, N as JoinOnExpr, O as IdentifierRef, P as JsonArrayAggExpr, Q as TableSource, R as LiteralExpr, S as EqColJoinOn, T as ExpressionFolder, U as OrExpr, V as NullCheckExpr, W as OrderByItem, X as SubqueryExpr, Y as SelectAstOptions, Z as TableRef, _ as DeleteAst, a as AndExpr, at as whereExprKinds, b as DoNothingConflictAction, c as AnyInsertOnConflictAction, d as AnyQueryAst, et as UpdateAst, f as AstRewriter, g as DefaultValueExpr, h as ColumnRef, i as AggregateOpFn, it as queryAstKinds, j as InsertValue, k as InsertAst, l as AnyInsertValue, m as BinaryOp, n as AggregateExpr, nt as isQueryAst, o as AnyExpression, p as BinaryExpr, q as ProjectionItem, r as AggregateFn, rt as isWhereExpr, s as AnyFromSource, t as AggregateCountFn, tt as WhereArg, u as AnyOperationArg, v as DerivedTableSource, w as ExprVisitor, x as DoUpdateSetConflictAction, y as Direction, z as LoweredStatement } from "../types-C3Hg-CVz.mjs";
+import { $ as TableRef, A as InsertOnConflict, B as NotExpr, C as ExistsExpr, D as ExpressionSource, E as ExpressionRewriter, F as JsonObjectEntry, G as ParamRef, H as OperationExpr, I as JsonObjectExpr, J as ProjectionItem, K as ParamRefBindingRefs, L as ListExpression, M as JoinAst, N as JoinOnExpr, O as IdentifierRef, P as JsonArrayAggExpr, Q as SubqueryExpr, R as LiteralExpr, S as EqColJoinOn, T as ExpressionFolder, U as OrExpr, V as NullCheckExpr, W as OrderByItem, X as SelectAst, Y as RawSqlExpr, Z as SelectAstOptions, _ as DeleteAst, a as AndExpr, at as isWhereExpr, b as DoNothingConflictAction, c as AnyInsertOnConflictAction, d as AnyQueryAst, et as TableSource, f as AstRewriter, g as DefaultValueExpr, h as ColumnRef, i as AggregateOpFn, it as isQueryAst, j as InsertValue, k as InsertAst, l as AnyInsertValue, m as BinaryOp, n as AggregateExpr, nt as UpdateAst, o as AnyExpression, ot as queryAstKinds, p as BinaryExpr, q as ProjectionExpr, r as AggregateFn, rt as WhereArg, s as AnyFromSource, st as whereExprKinds, t as AggregateCountFn, tt as ToWhereExpr, u as AnyOperationArg, v as DerivedTableSource, w as ExprVisitor, x as DoUpdateSetConflictAction, y as Direction, z as LoweredStatement } from "../types-BZcKgaYA.mjs";
+import { a as CodecMeta, c as DescriptorCodecId, d as ExtractCodecTypes, f as SqlCodecCallContext, i as CodecDescriptor, l as DescriptorCodecInput, m as SqlColumnRef, n as Codec, o as CodecTrait, p as SqlCodecInstanceContext, r as CodecCallContext, s as ContractCodecRegistry, t as AnyCodecDescriptor, u as DescriptorCodecTraits } from "../codec-types-BUfBna4G.mjs";
+import { n as CodecDescriptorRegistry } from "../query-lane-context-C2tLZGp4.mjs";
+import * as _$_prisma_next_framework_components_codec0 from "@prisma-next/framework-components/codec";
+import { CodecCallContext as CodecCallContext$1, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
+import { ContractMarkerRecord, JsonValue } from "@prisma-next/contract/types";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/ast/adapter-types.d.ts
-type AdapterTarget = string;
-interface MarkerStatement {
-  readonly sql: string;
-  readonly params: readonly unknown[];
-}
-interface AdapterProfile<TTarget extends AdapterTarget = AdapterTarget> {
-  readonly id: string;
-  readonly target: TTarget;
-  readonly capabilities: Record<string, unknown>;
-  /**
-   * Returns the adapter's default codec registry.
-   * The registry contains codecs provided by the adapter for converting
-   * between wire types and JavaScript types.
-   */
-  codecs(): CodecRegistry;
-  /**
-   * Returns the SQL statement to read the contract marker from the database.
-   * Each adapter provides target-specific SQL (e.g. schema-qualified table names,
-   * parameter placeholder style).
-   */
-  readMarkerStatement(): MarkerStatement;
-}
-interface LowererContext<TContract = unknown> {
-  readonly contract: TContract;
-  readonly params?: readonly unknown[];
-}
-type Lowerer<Ast = unknown, TContract = unknown, TBody = LoweredStatement> = (ast: Ast, context: LowererContext<TContract>) => TBody;
-/**
- * Lowers a query AST into a target-specific executable body (typically
- * `LoweredStatement` for SQL adapters). The `lower` method returns the body
- * directly; per-statement metadata, when needed, lives on the body itself
- * (e.g. `LoweredStatement.annotations`). Adapter-level metadata such as the
- * profile id is reachable via `profile.id` for callers that genuinely need it.
- */
-interface Adapter<Ast = unknown, TContract = unknown, TBody = LoweredStatement> {
-  readonly profile: AdapterProfile;
-  lower(ast: Ast, context: LowererContext<TContract>): TBody;
-}
-//#endregion
 //#region src/ast/driver-types.d.ts
 interface SqlExecuteRequest {
   readonly sql: string;
@@ -105,86 +70,198 @@ interface SqlQueryable {
   query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<SqlQueryResult<Row>>;
 }
 //#endregion
-//#region src/ast/sql-codecs.d.ts
+//#region src/ast/adapter-types.d.ts
+type AdapterTarget = string;
+interface MarkerStatement {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+}
+/**
+ * Outcome of an adapter's marker read. `no-table` means the marker storage itself is absent (e.g. attaching to a database that was never `db init`'d); `absent` means the storage exists but holds no row for the requested space; `present` carries the parsed record. Callers distinguish these so runtime telemetry and `requireMarker` policy can react to each case appropriately.
+ */
+type MarkerReadResult = {
+  readonly kind: 'present';
+  readonly record: ContractMarkerRecord;
+} | {
+  readonly kind: 'absent';
+} | {
+  readonly kind: 'no-table';
+};
+interface AdapterProfile<TTarget extends AdapterTarget = AdapterTarget> {
+  readonly id: string;
+  readonly target: TTarget;
+  readonly capabilities: Record<string, unknown>;
+  /**
+   * Reads the contract marker via the supplied queryable. The adapter owns the full flow — probing for the marker storage, issuing the read, and decoding the row — so callers receive a tagged result rather than a raw driver error when the marker storage is absent.
+   */
+  readMarker(queryable: SqlQueryable): Promise<MarkerReadResult>;
+}
+interface LowererContext<TContract = unknown> {
+  readonly contract: TContract;
+  readonly params?: readonly unknown[];
+}
+type Lowerer<Ast = unknown, TContract = unknown, TBody = LoweredStatement> = (ast: Ast, context: LowererContext<TContract>) => TBody;
+/**
+ * Lowers a query AST into a target-specific executable body (typically `LoweredStatement` for SQL adapters). The `lower` method returns the body directly; per-statement metadata, when needed, lives on the body itself (e.g. `LoweredStatement.annotations`). Adapter-level metadata such as the profile id is reachable via `profile.id` for callers that genuinely need it.
+ */
+interface Adapter<Ast = unknown, TContract = unknown, TBody = LoweredStatement> {
+  readonly profile: AdapterProfile;
+  lower(ast: Ast, context: LowererContext<TContract>): TBody;
+}
+//#endregion
+//#region src/ast/sql-codec-helpers.d.ts
 declare const SQL_CHAR_CODEC_ID: "sql/char@1";
 declare const SQL_VARCHAR_CODEC_ID: "sql/varchar@1";
 declare const SQL_INT_CODEC_ID: "sql/int@1";
 declare const SQL_FLOAT_CODEC_ID: "sql/float@1";
 declare const SQL_TEXT_CODEC_ID: "sql/text@1";
 declare const SQL_TIMESTAMP_CODEC_ID: "sql/timestamp@1";
-declare const codecs: CodecDefBuilder<{
-  char: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  varchar: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  int: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  float: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  text: Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-} & Record<"timestamp", Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
-  precision?: number;
-}, unknown>>>;
-declare const sqlCodecDefinitions: {
-  readonly char: {
-    readonly typeId: "sql/char@1";
-    readonly scalar: "char";
-    readonly codec: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly varchar: {
-    readonly typeId: "sql/varchar@1";
-    readonly scalar: "varchar";
-    readonly codec: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly int: {
-    readonly typeId: "sql/int@1";
-    readonly scalar: "int";
-    readonly codec: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly float: {
-    readonly typeId: "sql/float@1";
-    readonly scalar: "float";
-    readonly codec: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly text: {
-    readonly typeId: "sql/text@1";
-    readonly scalar: "text";
-    readonly codec: Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly timestamp: {
-    readonly typeId: "sql/timestamp@1";
-    readonly scalar: "timestamp";
-    readonly codec: Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
-      precision?: number;
-    }, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
+declare const sqlCharEncode: (value: string) => string;
+declare const sqlCharDecode: (wire: string) => string;
+declare const sqlCharRenderOutputType: (typeParams: {
+  readonly length?: number;
+}) => string | undefined;
+declare const sqlVarcharEncode: (value: string) => string;
+declare const sqlVarcharDecode: (wire: string) => string;
+declare const sqlVarcharRenderOutputType: (typeParams: {
+  readonly length?: number;
+}) => string | undefined;
+declare const sqlIntEncode: (value: number) => number;
+declare const sqlIntDecode: (wire: number) => number;
+declare const sqlFloatEncode: (value: number) => number;
+declare const sqlFloatDecode: (wire: number) => number;
+declare const sqlTextEncode: (value: string) => string;
+declare const sqlTextDecode: (wire: string) => string;
+declare const sqlTimestampEncode: (value: Date) => Date;
+declare const sqlTimestampDecode: (wire: Date) => Date;
+declare const sqlTimestampEncodeJson: (value: Date) => JsonValue;
+declare const sqlTimestampDecodeJson: (json: JsonValue) => Date;
+declare const sqlTimestampRenderOutputType: (typeParams: {
+  readonly precision?: number;
+}) => string;
+//#endregion
+//#region src/ast/sql-codecs.d.ts
+type LengthParams = {
+  readonly length?: number;
 };
-declare const sqlDataTypes: {
-  readonly char: "sql/char@1";
-  readonly varchar: "sql/varchar@1";
-  readonly int: "sql/int@1";
-  readonly float: "sql/float@1";
-  readonly text: "sql/text@1";
-  readonly timestamp: "sql/timestamp@1";
+type PrecisionParams = {
+  readonly precision?: number;
 };
-type SqlCodecTypes = typeof codecs.CodecTypes;
+declare class SqlTextCodec extends CodecImpl<typeof SQL_TEXT_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  encode(value: string, _ctx: CodecCallContext$1): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext$1): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class SqlTextDescriptor extends CodecDescriptorImpl<void> {
+  readonly codecId: "sql/text@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly targetTypes: readonly ["text"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => SqlTextCodec;
+}
+declare const sqlTextDescriptor: SqlTextDescriptor;
+declare const sqlTextColumn: () => _$_prisma_next_framework_components_codec0.ColumnSpec<SqlTextCodec, undefined>;
+declare class SqlIntCodec extends CodecImpl<typeof SQL_INT_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  encode(value: number, _ctx: CodecCallContext$1): Promise<number>;
+  decode(wire: number, _ctx: CodecCallContext$1): Promise<number>;
+  encodeJson(value: number): JsonValue;
+  decodeJson(json: JsonValue): number;
+}
+declare class SqlIntDescriptor extends CodecDescriptorImpl<void> {
+  readonly codecId: "sql/int@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["int"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => SqlIntCodec;
+}
+declare const sqlIntDescriptor: SqlIntDescriptor;
+declare const sqlIntColumn: () => _$_prisma_next_framework_components_codec0.ColumnSpec<SqlIntCodec, undefined>;
+declare class SqlFloatCodec extends CodecImpl<typeof SQL_FLOAT_CODEC_ID, readonly ['equality', 'order', 'numeric'], number, number> {
+  encode(value: number, _ctx: CodecCallContext$1): Promise<number>;
+  decode(wire: number, _ctx: CodecCallContext$1): Promise<number>;
+  encodeJson(value: number): JsonValue;
+  decodeJson(json: JsonValue): number;
+}
+declare class SqlFloatDescriptor extends CodecDescriptorImpl<void> {
+  readonly codecId: "sql/float@1";
+  readonly traits: readonly ["equality", "order", "numeric"];
+  readonly targetTypes: readonly ["float"];
+  readonly paramsSchema: StandardSchemaV1<void>;
+  factory(): (ctx: CodecInstanceContext) => SqlFloatCodec;
+}
+declare const sqlFloatDescriptor: SqlFloatDescriptor;
+declare const sqlFloatColumn: () => _$_prisma_next_framework_components_codec0.ColumnSpec<SqlFloatCodec, undefined>;
+declare class SqlCharCodec extends CodecImpl<typeof SQL_CHAR_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  encode(value: string, _ctx: CodecCallContext$1): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext$1): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class SqlCharDescriptor extends CodecDescriptorImpl<LengthParams> {
+  readonly codecId: "sql/char@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly targetTypes: readonly ["char"];
+  readonly paramsSchema: StandardSchemaV1<LengthParams>;
+  renderOutputType(params: LengthParams): string | undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlCharCodec;
+}
+declare const sqlCharDescriptor: SqlCharDescriptor;
+declare const sqlCharColumn: (params?: LengthParams) => _$_prisma_next_framework_components_codec0.ColumnSpec<SqlCharCodec, LengthParams>;
+declare class SqlVarcharCodec extends CodecImpl<typeof SQL_VARCHAR_CODEC_ID, readonly ['equality', 'order', 'textual'], string, string> {
+  encode(value: string, _ctx: CodecCallContext$1): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext$1): Promise<string>;
+  encodeJson(value: string): JsonValue;
+  decodeJson(json: JsonValue): string;
+}
+declare class SqlVarcharDescriptor extends CodecDescriptorImpl<LengthParams> {
+  readonly codecId: "sql/varchar@1";
+  readonly traits: readonly ["equality", "order", "textual"];
+  readonly targetTypes: readonly ["varchar"];
+  readonly paramsSchema: StandardSchemaV1<LengthParams>;
+  renderOutputType(params: LengthParams): string | undefined;
+  factory(_params: LengthParams): (ctx: CodecInstanceContext) => SqlVarcharCodec;
+}
+declare const sqlVarcharDescriptor: SqlVarcharDescriptor;
+declare const sqlVarcharColumn: (params?: LengthParams) => _$_prisma_next_framework_components_codec0.ColumnSpec<SqlVarcharCodec, LengthParams>;
+declare class SqlTimestampCodec extends CodecImpl<typeof SQL_TIMESTAMP_CODEC_ID, readonly ['equality', 'order'], Date, Date> {
+  encode(value: Date, _ctx: CodecCallContext$1): Promise<Date>;
+  decode(wire: Date, _ctx: CodecCallContext$1): Promise<Date>;
+  encodeJson(value: Date): JsonValue;
+  decodeJson(json: JsonValue): Date;
+}
+declare class SqlTimestampDescriptor extends CodecDescriptorImpl<PrecisionParams> {
+  readonly codecId: "sql/timestamp@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["timestamp"];
+  readonly paramsSchema: StandardSchemaV1<PrecisionParams>;
+  renderOutputType(params: PrecisionParams): string | undefined;
+  factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => SqlTimestampCodec;
+}
+declare const sqlTimestampDescriptor: SqlTimestampDescriptor;
+declare const sqlTimestampColumn: (params?: PrecisionParams) => _$_prisma_next_framework_components_codec0.ColumnSpec<SqlTimestampCodec, PrecisionParams>;
 //#endregion
 //#region src/ast/util.d.ts
 declare function compact<T extends Record<string, unknown>>(o: T): T;
+/**
+ * Walks an AST's parameter references in first-encounter order and dedupes
+ * by ParamRef identity. The single canonical helper used by every consumer
+ * that aligns `plan.params` with metadata-by-index — the SQL builder lane,
+ * the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's
+ * `$N` index map — so the four walks cannot drift in dedupe semantics.
+ *
+ * SQLite's `?`-placeholder renderer intentionally does NOT use this helper
+ * because it needs one params entry per occurrence in the SQL.
+ */
+declare function collectOrderedParamRefs(ast: AnyQueryAst): ReadonlyArray<ParamRef>;
+//#endregion
+//#region src/ast/validate-param-refs.d.ts
+/**
+ * Validate that every parameterized-codec `ParamRef` in `plan` carries `refs`. Throws `RUNTIME.PARAM_REF_REFS_REQUIRED` (a runtime envelope) naming the codec id and the binding label when the invariant is violated. Returns the plan unchanged on success — callers that prefer a side-effecting assertion can ignore the return value.
+ *
+ * The `registry` is consulted via `descriptorFor(codecId).isParameterized` — `true` whenever the descriptor's `paramsSchema` is not the singleton `voidParamsSchema`.
+ */
+declare function validateParamRefRefs(plan: AnyQueryAst, registry: CodecDescriptorRegistry): void;
 //#endregion
-export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyOperationArg, AnyQueryAst, AstRewriter, BinaryExpr, BinaryOp, Codec, CodecDefBuilder, CodecId, CodecInput, CodecMeta, CodecParamsDescriptor, CodecRegistry, CodecTrait, CodecTraits, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ExprVisitor, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, ExtractDataTypes, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonObjectEntry, JsonObjectExpr, ListExpression, LiteralExpr, LoweredStatement, Lowerer, LowererContext, MarkerStatement, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionExpr, ProjectionItem, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SelectAstOptions, SqlCodecTypes, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, SqlQueryable, SqlTransaction, SubqueryExpr, TableRef, TableSource, ToWhereExpr, UpdateAst, WhereArg, codec, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
+export { Adapter, AdapterProfile, AdapterTarget, AggregateCountFn, AggregateExpr, AggregateFn, AggregateOpFn, AndExpr, AnyCodecDescriptor, AnyExpression, AnyFromSource, AnyInsertOnConflictAction, AnyInsertValue, AnyOperationArg, AnyQueryAst, AstRewriter, BinaryExpr, BinaryOp, Codec, CodecCallContext, CodecDescriptor, CodecMeta, CodecTrait, ColumnRef, ContractCodecRegistry, DefaultValueExpr, DeleteAst, DerivedTableSource, DescriptorCodecId, DescriptorCodecInput, DescriptorCodecTraits, Direction, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, ExprVisitor, ExpressionFolder, ExpressionRewriter, ExpressionSource, ExtractCodecTypes, IdentifierRef, InsertAst, InsertOnConflict, InsertValue, JoinAst, JoinOnExpr, JsonArrayAggExpr, JsonObjectEntry, JsonObjectExpr, ListExpression, LiteralExpr, LoweredStatement, Lowerer, LowererContext, MarkerReadResult, MarkerStatement, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ParamRefBindingRefs, ProjectionExpr, ProjectionItem, RawSqlExpr, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SelectAstOptions, SqlCharCodec, SqlCharDescriptor, SqlCodecCallContext, SqlCodecInstanceContext, SqlColumnRef, SqlConnection, SqlDriver, SqlDriverState, SqlExecuteRequest, SqlExplainResult, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlQueryResult, SqlQueryable, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlTransaction, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableRef, TableSource, ToWhereExpr, UpdateAst, WhereArg, collectOrderedParamRefs, compact, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, validateParamRefRefs, whereExprKinds };
 //# sourceMappingURL=ast.d.mts.map