@prisma-next/sql-relational-core 0.3.0-pr.93.5 → 0.3.0-pr.94.1

package/dist/errors-BwxypN2Q.mjs

@@ -0,0 +1,3 @@
+import { planInvalid as planInvalid$1, planUnsupported } from "@prisma-next/plan";
+
+export { planUnsupported as n, planInvalid$1 as t };

package/dist/errors-CLx1Ylq0.d.mts

@@ -0,0 +1,2 @@
+import { planInvalid as planInvalid$1, planUnsupported } from "@prisma-next/plan";
+export { planUnsupported as n, planInvalid$1 as t };

package/dist/exports/ast.d.mts

@@ -0,0 +1,123 @@
+import { a as CodecInput, c as CodecRegistry, d as codec, f as createCodecRegistry, i as CodecId, l as ExtractCodecTypes, n as Codec, o as CodecMeta, p as defineCodecs, r as CodecDefBuilder, s as CodecOutput, u as ExtractDataTypes } from "../query-lane-context-wr_XXnB5.mjs";
+import { C as UpdateAst, S as TableRef, _ as LoweredStatement, a as ColumnRef, b as QueryAst, c as ExistsExpr, d as IncludeAst, f as IncludeRef, g as LiteralExpr, h as JoinOnExpr, i as BinaryOp, l as Expression, m as JoinAst, o as DeleteAst, p as InsertAst, r as BinaryExpr, s as Direction, u as ExpressionSource, v as OperationExpr, w as isOperationExpr, x as SelectAst, y as ParamRef } from "../plan-9PvH-Tu3.mjs";
+import { y as JoinOnBuilder } from "../types-Bg2kUmUA.mjs";
+
+//#region src/ast/adapter-types.d.ts
+type AdapterTarget = string;
+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;
+}
+interface LoweredPayload<TBody = unknown> {
+  readonly profileId?: string;
+  readonly body: TBody;
+  readonly annotations?: Record<string, unknown>;
+}
+interface LowererContext<TContract = unknown> {
+  readonly contract: TContract;
+  readonly params?: readonly unknown[];
+}
+type Lowerer<Ast = unknown, TContract = unknown, TBody = unknown> = (ast: Ast, context: LowererContext<TContract>) => LoweredPayload<TBody>;
+interface Adapter<Ast = unknown, TContract = unknown, TBody = unknown> {
+  readonly profile: AdapterProfile;
+  lower(ast: Ast, context: LowererContext<TContract>): LoweredPayload<TBody>;
+}
+//#endregion
+//#region src/ast/common.d.ts
+declare function createTableRef(name: string): TableRef;
+declare function createColumnRef(table: string, column: string): ColumnRef;
+declare function createParamRef(index: number, name?: string): ParamRef;
+declare function createOperationExpr(operation: OperationExpr): OperationExpr;
+declare function createLiteralExpr(value: unknown): LiteralExpr;
+//#endregion
+//#region src/ast/delete.d.ts
+interface CreateDeleteAstOptions {
+  readonly table: TableRef;
+  readonly where: BinaryExpr;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+declare function createDeleteAst(options: CreateDeleteAstOptions): DeleteAst;
+//#endregion
+//#region src/ast/driver-types.d.ts
+interface SqlExecuteRequest {
+  readonly sql: string;
+  readonly params?: readonly unknown[];
+}
+interface SqlQueryResult<Row = Record<string, unknown>> {
+  readonly rows: ReadonlyArray<Row>;
+  readonly rowCount?: number | null;
+  readonly [key: string]: unknown;
+}
+interface SqlExplainResult<Row = Record<string, unknown>> {
+  readonly rows: ReadonlyArray<Row>;
+}
+interface SqlDriver {
+  connect(): Promise<void>;
+  execute<Row = Record<string, unknown>>(request: SqlExecuteRequest): AsyncIterable<Row>;
+  explain?(request: SqlExecuteRequest): Promise<SqlExplainResult>;
+  query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<SqlQueryResult<Row>>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/ast/insert.d.ts
+interface CreateInsertAstOptions {
+  readonly table: TableRef;
+  readonly values: Record<string, ColumnRef | ParamRef>;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+declare function createInsertAst(options: CreateInsertAstOptions): InsertAst;
+//#endregion
+//#region src/ast/join.d.ts
+declare function createJoin(joinType: 'inner' | 'left' | 'right' | 'full', table: TableRef, on: JoinOnExpr): JoinAst;
+declare function createJoinOnExpr(left: ColumnRef, right: ColumnRef): JoinOnExpr;
+declare function createJoinOnBuilder(): JoinOnBuilder;
+//#endregion
+//#region src/ast/order.d.ts
+declare function createOrderByItem(expr: ColumnRef | OperationExpr, dir: 'asc' | 'desc'): {
+  expr: ColumnRef | OperationExpr;
+  dir: Direction;
+};
+//#endregion
+//#region src/ast/predicate.d.ts
+declare function createBinaryExpr(op: BinaryOp, left: Expression, right: Expression | ParamRef): BinaryExpr;
+declare function createExistsExpr(not: boolean, subquery: SelectAst): ExistsExpr;
+//#endregion
+//#region src/ast/select.d.ts
+interface CreateSelectAstOptions {
+  readonly from: TableRef;
+  readonly joins?: ReadonlyArray<JoinAst>;
+  readonly includes?: ReadonlyArray<IncludeAst>;
+  readonly project: ReadonlyArray<{
+    alias: string;
+    expr: ColumnRef | IncludeRef | OperationExpr;
+  }>;
+  readonly where?: BinaryExpr | ExistsExpr;
+  readonly orderBy?: ReadonlyArray<{
+    expr: ColumnRef | OperationExpr;
+    dir: Direction;
+  }>;
+  readonly limit?: number;
+}
+declare function createSelectAst(options: CreateSelectAstOptions): SelectAst;
+//#endregion
+//#region src/ast/update.d.ts
+interface CreateUpdateAstOptions {
+  readonly table: TableRef;
+  readonly set: Record<string, ColumnRef | ParamRef>;
+  readonly where: BinaryExpr;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+declare function createUpdateAst(options: CreateUpdateAstOptions): UpdateAst;
+//#endregion
+//#region src/ast/util.d.ts
+declare function compact<T extends Record<string, unknown>>(o: T): T;
+//#endregion
+export { Adapter, AdapterProfile, AdapterTarget, BinaryExpr, BinaryOp, Codec, CodecDefBuilder, CodecId, CodecInput, CodecMeta, CodecOutput, CodecRegistry, ColumnRef, CreateDeleteAstOptions, CreateInsertAstOptions, CreateSelectAstOptions, CreateUpdateAstOptions, DeleteAst, Direction, ExistsExpr, Expression, ExpressionSource, ExtractCodecTypes, ExtractDataTypes, IncludeAst, IncludeRef, InsertAst, JoinAst, JoinOnExpr, LiteralExpr, LoweredPayload, LoweredStatement, Lowerer, LowererContext, OperationExpr, ParamRef, QueryAst, SelectAst, SqlDriver, SqlExecuteRequest, SqlExplainResult, SqlQueryResult, TableRef, UpdateAst, codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isOperationExpr };
+//# sourceMappingURL=ast.d.mts.map

package/dist/exports/ast.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.mts","names":[],"sources":["../../src/ast/adapter-types.ts","../../src/ast/common.ts","../../src/ast/delete.ts","../../src/ast/driver-types.ts","../../src/ast/insert.ts","../../src/ast/join.ts","../../src/ast/order.ts","../../src/ast/predicate.ts","../../src/ast/select.ts","../../src/ast/update.ts","../../src/ast/util.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/exports/ast.mjs

@@ -0,0 +1,304 @@
+import { n as isColumnBuilder } from "../types-D_FRJvm0.mjs";
+import { planInvalid } from "@prisma-next/plan";
+
+//#region src/ast/codec-types.ts
+/**
+* Implementation of CodecRegistry.
+*/
+var CodecRegistryImpl = class {
+	_byId = /* @__PURE__ */ new Map();
+	_byScalar = /* @__PURE__ */ new Map();
+	/**
+	* Map-like interface for codec lookup by ID.
+	* Example: registry.get('pg/text@1')
+	*/
+	get(id) {
+		return this._byId.get(id);
+	}
+	/**
+	* Check if a codec with the given ID is registered.
+	*/
+	has(id) {
+		return this._byId.has(id);
+	}
+	/**
+	* Get all codecs that handle a given scalar type.
+	* Returns an empty frozen array if no codecs are found.
+	* Example: registry.getByScalar('text') → [codec1, codec2, ...]
+	*/
+	getByScalar(scalar) {
+		return this._byScalar.get(scalar) ?? Object.freeze([]);
+	}
+	/**
+	* Get the default codec for a scalar type (first registered codec).
+	* Returns undefined if no codec handles this scalar type.
+	*/
+	getDefaultCodec(scalar) {
+		return this._byScalar.get(scalar)?.[0];
+	}
+	/**
+	* Register a codec in the registry.
+	* Throws an error if a codec with the same ID is already registered.
+	*
+	* @param codec - The codec to register
+	* @throws Error if a codec with the same ID already exists
+	*/
+	register(codec$1) {
+		if (this._byId.has(codec$1.id)) throw new Error(`Codec with ID '${codec$1.id}' is already registered`);
+		this._byId.set(codec$1.id, codec$1);
+		for (const scalarType of codec$1.targetTypes) {
+			const existing = this._byScalar.get(scalarType);
+			if (existing) existing.push(codec$1);
+			else this._byScalar.set(scalarType, [codec$1]);
+		}
+	}
+	/**
+	* Returns an iterator over all registered codecs.
+	* Useful for iterating through codecs from another registry.
+	*/
+	*[Symbol.iterator]() {
+		for (const codec$1 of this._byId.values()) yield codec$1;
+	}
+	/**
+	* Returns an iterable of all registered codecs.
+	*/
+	values() {
+		return this._byId.values();
+	}
+};
+/**
+* Codec factory - creates a codec with typeId and encode/decode functions.
+*/
+function codec(config) {
+	return {
+		id: config.typeId,
+		targetTypes: config.targetTypes,
+		...config.meta ? { meta: config.meta } : {},
+		encode: config.encode,
+		decode: config.decode
+	};
+}
+/**
+* Implementation of CodecDefBuilder.
+*/
+var CodecDefBuilderImpl = class CodecDefBuilderImpl {
+	_codecs;
+	CodecTypes;
+	dataTypes;
+	constructor(codecs) {
+		this._codecs = codecs;
+		const codecTypes = {};
+		for (const [, codecImpl] of Object.entries(this._codecs)) {
+			const codecImplTyped = codecImpl;
+			codecTypes[codecImplTyped.id] = {
+				input: void 0,
+				output: void 0
+			};
+		}
+		this.CodecTypes = codecTypes;
+		const dataTypes = {};
+		for (const key in this._codecs) if (Object.hasOwn(this._codecs, key)) dataTypes[key] = this._codecs[key].id;
+		this.dataTypes = dataTypes;
+	}
+	add(scalarName, codecImpl) {
+		return new CodecDefBuilderImpl({
+			...this._codecs,
+			[scalarName]: codecImpl
+		});
+	}
+	/**
+	* Derive codecDefinitions structure.
+	*/
+	get codecDefinitions() {
+		const result = {};
+		for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {
+			const codec$1 = codecImpl;
+			result[scalarName] = {
+				typeId: codec$1.id,
+				scalar: scalarName,
+				codec: codec$1,
+				input: void 0,
+				output: void 0,
+				jsType: void 0
+			};
+		}
+		return result;
+	}
+};
+/**
+* Create a new codec registry.
+*/
+function createCodecRegistry() {
+	return new CodecRegistryImpl();
+}
+/**
+* Create a new codec definition builder.
+*/
+function defineCodecs() {
+	return new CodecDefBuilderImpl({});
+}
+
+//#endregion
+//#region src/ast/util.ts
+function compact(o) {
+	const out = {};
+	for (const [k, v] of Object.entries(o)) {
+		if (v === void 0 || v === null) continue;
+		if (Array.isArray(v) && v.length === 0) continue;
+		out[k] = v;
+	}
+	return out;
+}
+
+//#endregion
+//#region src/ast/common.ts
+function createTableRef(name) {
+	return {
+		kind: "table",
+		name
+	};
+}
+function createColumnRef(table, column) {
+	return {
+		kind: "col",
+		table,
+		column
+	};
+}
+function createParamRef(index, name) {
+	return compact({
+		kind: "param",
+		index,
+		name
+	});
+}
+function createOperationExpr(operation) {
+	return operation;
+}
+function createLiteralExpr(value) {
+	return {
+		kind: "literal",
+		value
+	};
+}
+
+//#endregion
+//#region src/ast/delete.ts
+function createDeleteAst(options) {
+	return compact({
+		kind: "delete",
+		table: options.table,
+		where: options.where,
+		returning: options.returning
+	});
+}
+
+//#endregion
+//#region src/ast/insert.ts
+function createInsertAst(options) {
+	return compact({
+		kind: "insert",
+		table: options.table,
+		values: options.values,
+		returning: options.returning
+	});
+}
+
+//#endregion
+//#region src/ast/join.ts
+function createJoin(joinType, table, on) {
+	return {
+		kind: "join",
+		joinType,
+		table,
+		on
+	};
+}
+function createJoinOnExpr(left, right) {
+	return {
+		kind: "eqCol",
+		left,
+		right
+	};
+}
+var JoinOnBuilderImpl = class {
+	eqCol(left, right) {
+		if (!left || !isColumnBuilder(left)) throw planInvalid("Join ON left operand must be a column");
+		if (!right || !isColumnBuilder(right)) throw planInvalid("Join ON right operand must be a column");
+		const leftCol = left;
+		const rightCol = right;
+		if (leftCol.table === rightCol.table) throw planInvalid("Self-joins are not supported in MVP");
+		return {
+			kind: "join-on",
+			left,
+			right
+		};
+	}
+};
+function createJoinOnBuilder() {
+	return new JoinOnBuilderImpl();
+}
+
+//#endregion
+//#region src/ast/order.ts
+function createOrderByItem(expr, dir) {
+	return {
+		expr,
+		dir
+	};
+}
+
+//#endregion
+//#region src/ast/predicate.ts
+function createBinaryExpr(op, left, right) {
+	return {
+		kind: "bin",
+		op,
+		left,
+		right
+	};
+}
+function createExistsExpr(not, subquery) {
+	return {
+		kind: "exists",
+		not,
+		subquery
+	};
+}
+
+//#endregion
+//#region src/ast/select.ts
+function createSelectAst(options) {
+	return compact({
+		kind: "select",
+		from: options.from,
+		joins: options.joins,
+		includes: options.includes,
+		project: options.project,
+		where: options.where,
+		orderBy: options.orderBy,
+		limit: options.limit
+	});
+}
+
+//#endregion
+//#region src/ast/types.ts
+function isOperationExpr(expr) {
+	return expr.kind === "operation";
+}
+
+//#endregion
+//#region src/ast/update.ts
+function createUpdateAst(options) {
+	return compact({
+		kind: "update",
+		table: options.table,
+		set: options.set,
+		where: options.where,
+		returning: options.returning
+	});
+}
+
+//#endregion
+export { codec, compact, createBinaryExpr, createCodecRegistry, createColumnRef, createDeleteAst, createExistsExpr, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnExpr, createLiteralExpr, createOperationExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst, defineCodecs, isOperationExpr };
+//# sourceMappingURL=ast.mjs.map

package/dist/exports/ast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.mjs","names":["codec","codecTypes: Record<string, { readonly input: unknown; readonly output: unknown }>","result: Record<\n      string,\n      {\n        typeId: string;\n        scalar: string;\n        codec: Codec;\n        input: unknown;\n        output: unknown;\n        jsType: unknown;\n      }\n    >","out: Record<string, unknown>"],"sources":["../../src/ast/codec-types.ts","../../src/ast/util.ts","../../src/ast/common.ts","../../src/ast/delete.ts","../../src/ast/insert.ts","../../src/ast/join.ts","../../src/ast/order.ts","../../src/ast/predicate.ts","../../src/ast/select.ts","../../src/ast/types.ts","../../src/ast/update.ts"],"sourcesContent":["import type { O } from 'ts-toolbelt';\n\n/**\n * Codec metadata for database-specific type information.\n * Used for schema introspection and verification.\n */\nexport interface CodecMeta {\n  readonly db?: {\n    readonly sql?: {\n      readonly postgres?: {\n        readonly nativeType: string; // e.g. 'integer', 'text', 'vector', 'timestamp with time zone'\n      };\n    };\n  };\n}\n\n/**\n * Codec interface for encoding/decoding values between wire format and JavaScript types.\n *\n * Codecs are pure, synchronous functions with no side effects or IO.\n * They provide deterministic conversion between database wire types and JS values.\n */\nexport interface Codec<Id extends string = string, TWire = unknown, TJs = unknown> {\n  /**\n   * Namespaced codec identifier in format 'namespace/name@version'\n   * Examples: 'pg/text@1', 'pg/uuid@1', 'pg/timestamptz@1'\n   */\n  readonly id: Id;\n\n  /**\n   * Contract scalar type IDs that this codec can handle.\n   * Examples: ['text'], ['int4', 'float8'], ['timestamp', 'timestamptz']\n   */\n  readonly targetTypes: readonly string[];\n\n  /**\n   * Optional metadata for database-specific type information.\n   * Used for schema introspection and verification.\n   */\n  readonly meta?: CodecMeta;\n\n  /**\n   * Decode a wire value (from database) to JavaScript type.\n   * Must be synchronous and pure (no side effects).\n   */\n  decode(wire: TWire): TJs;\n\n  /**\n   * Encode a JavaScript value to wire format (for database).\n   * Optional - if not provided, values pass through unchanged.\n   * Must be synchronous and pure (no side effects).\n   */\n  encode?(value: TJs): TWire;\n}\n\n/**\n * Registry interface for codecs organized by ID and by contract scalar type.\n *\n * The registry allows looking up codecs by their namespaced ID or by the\n * contract scalar types they handle. Multiple codecs may handle the same\n * scalar type; ordering in byScalar reflects preference (adapter first,\n * then packs, then app overrides).\n */\nexport interface CodecRegistry {\n  get(id: string): Codec<string> | undefined;\n  has(id: string): boolean;\n  getByScalar(scalar: string): readonly Codec<string>[];\n  getDefaultCodec(scalar: string): Codec<string> | undefined;\n  register(codec: Codec<string>): void;\n  [Symbol.iterator](): Iterator<Codec<string>>;\n  values(): IterableIterator<Codec<string>>;\n}\n\n/**\n * Implementation of CodecRegistry.\n */\nclass CodecRegistryImpl implements CodecRegistry {\n  private readonly _byId = new Map<string, Codec<string>>();\n  private readonly _byScalar = new Map<string, Codec<string>[]>();\n\n  /**\n   * Map-like interface for codec lookup by ID.\n   * Example: registry.get('pg/text@1')\n   */\n  get(id: string): Codec<string> | undefined {\n    return this._byId.get(id);\n  }\n\n  /**\n   * Check if a codec with the given ID is registered.\n   */\n  has(id: string): boolean {\n    return this._byId.has(id);\n  }\n\n  /**\n   * Get all codecs that handle a given scalar type.\n   * Returns an empty frozen array if no codecs are found.\n   * Example: registry.getByScalar('text') → [codec1, codec2, ...]\n   */\n  getByScalar(scalar: string): readonly Codec<string>[] {\n    return this._byScalar.get(scalar) ?? Object.freeze([]);\n  }\n\n  /**\n   * Get the default codec for a scalar type (first registered codec).\n   * Returns undefined if no codec handles this scalar type.\n   */\n  getDefaultCodec(scalar: string): Codec<string> | undefined {\n    const _codecs = this._byScalar.get(scalar);\n    return _codecs?.[0];\n  }\n\n  /**\n   * Register a codec in the registry.\n   * Throws an error if a codec with the same ID is already registered.\n   *\n   * @param codec - The codec to register\n   * @throws Error if a codec with the same ID already exists\n   */\n  register(codec: Codec<string>): void {\n    if (this._byId.has(codec.id)) {\n      throw new Error(`Codec with ID '${codec.id}' is already registered`);\n    }\n\n    this._byId.set(codec.id, codec);\n\n    // Update byScalar mapping\n    for (const scalarType of codec.targetTypes) {\n      const existing = this._byScalar.get(scalarType);\n      if (existing) {\n        existing.push(codec);\n      } else {\n        this._byScalar.set(scalarType, [codec]);\n      }\n    }\n  }\n\n  /**\n   * Returns an iterator over all registered codecs.\n   * Useful for iterating through codecs from another registry.\n   */\n  *[Symbol.iterator](): Iterator<Codec<string>> {\n    for (const codec of this._byId.values()) {\n      yield codec;\n    }\n  }\n\n  /**\n   * Returns an iterable of all registered codecs.\n   */\n  values(): IterableIterator<Codec<string>> {\n    return this._byId.values();\n  }\n}\n\n/**\n * Codec factory - creates a codec with typeId and encode/decode functions.\n */\nexport function codec<Id extends string, TWire, TJs>(config: {\n  typeId: Id;\n  targetTypes: readonly string[];\n  encode: (value: TJs) => TWire;\n  decode: (wire: TWire) => TJs;\n  meta?: CodecMeta;\n}): Codec<Id, TWire, TJs> {\n  return {\n    id: config.typeId,\n    targetTypes: config.targetTypes,\n    ...(config.meta ? { meta: config.meta } : {}),\n    encode: config.encode,\n    decode: config.decode,\n  };\n}\n\n/**\n * Type helpers to extract codec types.\n */\nexport type CodecId<T> =\n  T extends Codec<infer Id, unknown, unknown>\n    ? Id\n    : T extends { readonly id: infer Id }\n      ? Id\n      : never;\nexport type CodecInput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;\nexport type CodecOutput<T> = T extends Codec<string, unknown, infer JsT> ? JsT : never;\n\n/**\n * Type helper to extract codec types from builder instance.\n */\nexport type ExtractCodecTypes<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> = {\n  readonly [K in keyof ScalarNames as ScalarNames[K] extends Codec<infer Id, unknown, unknown>\n    ? Id\n    : never]: {\n    readonly input: CodecInput<ScalarNames[K]>;\n    readonly output: CodecOutput<ScalarNames[K]>;\n  };\n};\n\n/**\n * Type helper to extract data type IDs from builder instance.\n * Uses ExtractCodecTypes which preserves literal types as keys.\n * Since ExtractCodecTypes<Record<K, ScalarNames[K]>> has exactly one key (the Id),\n * we extract it by creating a mapped type that uses the Id as both key and value,\n * then extract the value type. This preserves literal types.\n */\nexport type ExtractDataTypes<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> },\n> = {\n  readonly [K in keyof ScalarNames]: {\n    readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n  }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n};\n\n/**\n * Builder interface for declaring codecs.\n */\nexport interface CodecDefBuilder<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> {\n  readonly CodecTypes: ExtractCodecTypes<ScalarNames>;\n\n  add<ScalarName extends string, CodecImpl extends Codec<string>>(\n    scalarName: ScalarName,\n    codecImpl: CodecImpl,\n  ): CodecDefBuilder<\n    O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>\n  >;\n\n  readonly codecDefinitions: {\n    readonly [K in keyof ScalarNames]: {\n      readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown>\n        ? Id\n        : never;\n      readonly scalar: K;\n      readonly codec: ScalarNames[K];\n      readonly input: CodecInput<ScalarNames[K]>;\n      readonly output: CodecOutput<ScalarNames[K]>;\n      readonly jsType: CodecOutput<ScalarNames[K]>;\n    };\n  };\n\n  readonly dataTypes: {\n    readonly [K in keyof ScalarNames]: {\n      readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n  };\n}\n\n/**\n * Implementation of CodecDefBuilder.\n */\nclass CodecDefBuilderImpl<\n  ScalarNames extends { readonly [K in keyof ScalarNames]: Codec<string> } = Record<never, never>,\n> implements CodecDefBuilder<ScalarNames>\n{\n  private readonly _codecs: ScalarNames;\n\n  public readonly CodecTypes: ExtractCodecTypes<ScalarNames>;\n  public readonly dataTypes: {\n    readonly [K in keyof ScalarNames]: {\n      readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n    }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n  };\n\n  constructor(codecs: ScalarNames) {\n    this._codecs = codecs;\n\n    // Populate CodecTypes from codecs\n    const codecTypes: Record<string, { readonly input: unknown; readonly output: unknown }> = {};\n    for (const [, codecImpl] of Object.entries(this._codecs)) {\n      const codecImplTyped = codecImpl as Codec<string>;\n      codecTypes[codecImplTyped.id] = {\n        input: undefined as unknown as CodecInput<typeof codecImplTyped>,\n        output: undefined as unknown as CodecOutput<typeof codecImplTyped>,\n      };\n    }\n    this.CodecTypes = codecTypes as ExtractCodecTypes<ScalarNames>;\n\n    // Populate dataTypes from codecs - extract id property from each codec\n    // Build object preserving keys from ScalarNames\n    // Type assertion is safe because we know ScalarNames structure matches the return type\n    // biome-ignore lint/suspicious/noExplicitAny: dynamic codec mapping requires any\n    const dataTypes = {} as any;\n    for (const key in this._codecs) {\n      if (Object.hasOwn(this._codecs, key)) {\n        const codec = this._codecs[key] as Codec<string>;\n        dataTypes[key] = codec.id;\n      }\n    }\n    this.dataTypes = dataTypes as {\n      readonly [K in keyof ScalarNames]: {\n        readonly [Id in keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>]: Id;\n      }[keyof ExtractCodecTypes<Record<K, ScalarNames[K]>>];\n    };\n  }\n\n  add<ScalarName extends string, CodecImpl extends Codec<string>>(\n    scalarName: ScalarName,\n    codecImpl: CodecImpl,\n  ): CodecDefBuilder<\n    O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>\n  > {\n    return new CodecDefBuilderImpl({\n      ...this._codecs,\n      [scalarName]: codecImpl,\n    } as O.Overwrite<ScalarNames, Record<ScalarName, CodecImpl>> & Record<ScalarName, CodecImpl>);\n  }\n\n  /**\n   * Derive codecDefinitions structure.\n   */\n  get codecDefinitions(): {\n    readonly [K in keyof ScalarNames]: {\n      readonly typeId: ScalarNames[K] extends Codec<infer Id, unknown, unknown> ? Id : never;\n      readonly scalar: K;\n      readonly codec: ScalarNames[K];\n      readonly input: CodecInput<ScalarNames[K]>;\n      readonly output: CodecOutput<ScalarNames[K]>;\n      readonly jsType: CodecOutput<ScalarNames[K]>;\n    };\n  } {\n    const result: Record<\n      string,\n      {\n        typeId: string;\n        scalar: string;\n        codec: Codec;\n        input: unknown;\n        output: unknown;\n        jsType: unknown;\n      }\n    > = {};\n\n    for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {\n      const codec = codecImpl as Codec<string>;\n      result[scalarName] = {\n        typeId: codec.id,\n        scalar: scalarName,\n        codec: codec,\n        input: undefined as unknown as CodecInput<typeof codec>,\n        output: undefined as unknown as CodecOutput<typeof codec>,\n        jsType: undefined as unknown as CodecOutput<typeof codec>,\n      };\n    }\n\n    return result as {\n      readonly [K in keyof ScalarNames]: {\n        readonly typeId: ScalarNames[K] extends Codec<infer Id extends string, unknown, unknown>\n          ? Id\n          : never;\n        readonly scalar: K;\n        readonly codec: ScalarNames[K];\n        readonly input: CodecInput<ScalarNames[K]>;\n        readonly output: CodecOutput<ScalarNames[K]>;\n        readonly jsType: CodecOutput<ScalarNames[K]>;\n      };\n    };\n  }\n}\n\n/**\n * Create a new codec registry.\n */\nexport function createCodecRegistry(): CodecRegistry {\n  return new CodecRegistryImpl();\n}\n\n/**\n * Create a new codec definition builder.\n */\nexport function defineCodecs(): CodecDefBuilder<Record<never, never>> {\n  return new CodecDefBuilderImpl({});\n}\n","export function compact<T extends Record<string, unknown>>(o: T): T {\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(o)) {\n    if (v === undefined || v === null) continue;\n    if (Array.isArray(v) && v.length === 0) continue;\n    out[k] = v;\n  }\n  return out as T;\n}\n","import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef, TableRef } from './types';\nimport { compact } from './util';\n\nexport function createTableRef(name: string): TableRef {\n  return {\n    kind: 'table',\n    name,\n  };\n}\n\nexport function createColumnRef(table: string, column: string): ColumnRef {\n  return {\n    kind: 'col',\n    table,\n    column,\n  };\n}\n\nexport function createParamRef(index: number, name?: string): ParamRef {\n  return compact({\n    kind: 'param',\n    index,\n    name,\n  }) as ParamRef;\n}\n\nexport function createOperationExpr(operation: OperationExpr): OperationExpr {\n  return operation;\n}\n\nexport function createLiteralExpr(value: unknown): LiteralExpr {\n  return {\n    kind: 'literal',\n    value,\n  };\n}\n","import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types';\nimport { compact } from './util';\n\nexport interface CreateDeleteAstOptions {\n  readonly table: TableRef;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createDeleteAst(options: CreateDeleteAstOptions): DeleteAst {\n  return compact({\n    kind: 'delete',\n    table: options.table,\n    where: options.where,\n    returning: options.returning,\n  }) as DeleteAst;\n}\n","import type { ColumnRef, InsertAst, ParamRef, TableRef } from './types';\nimport { compact } from './util';\n\nexport interface CreateInsertAstOptions {\n  readonly table: TableRef;\n  readonly values: Record<string, ColumnRef | ParamRef>;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createInsertAst(options: CreateInsertAstOptions): InsertAst {\n  return compact({\n    kind: 'insert',\n    table: options.table,\n    values: options.values,\n    returning: options.returning,\n  }) as InsertAst;\n}\n","import { planInvalid } from '@prisma-next/plan';\nimport type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types';\nimport { isColumnBuilder } from '../types';\nimport type { ColumnRef, JoinAst, JoinOnExpr, TableRef } from './types';\n\nexport function createJoin(\n  joinType: 'inner' | 'left' | 'right' | 'full',\n  table: TableRef,\n  on: JoinOnExpr,\n): JoinAst {\n  return {\n    kind: 'join',\n    joinType,\n    table,\n    on,\n  };\n}\n\nexport function createJoinOnExpr(left: ColumnRef, right: ColumnRef): JoinOnExpr {\n  return {\n    kind: 'eqCol',\n    left,\n    right,\n  };\n}\n\nclass JoinOnBuilderImpl implements JoinOnBuilder {\n  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate {\n    if (!left || !isColumnBuilder(left)) {\n      throw planInvalid('Join ON left operand must be a column');\n    }\n\n    if (!right || !isColumnBuilder(right)) {\n      throw planInvalid('Join ON right operand must be a column');\n    }\n\n    // TypeScript can't narrow ColumnBuilder properly, so we assert\n    const leftCol = left as unknown as { table: string; column: string };\n    const rightCol = right as unknown as { table: string; column: string };\n    if (leftCol.table === rightCol.table) {\n      throw planInvalid('Self-joins are not supported in MVP');\n    }\n\n    return {\n      kind: 'join-on',\n      left: left as AnyColumnBuilder,\n      right: right as AnyColumnBuilder,\n    };\n  }\n}\n\nexport function createJoinOnBuilder(): JoinOnBuilder {\n  return new JoinOnBuilderImpl();\n}\n","import type { ColumnRef, Direction, OperationExpr } from './types';\n\nexport function createOrderByItem(\n  expr: ColumnRef | OperationExpr,\n  dir: 'asc' | 'desc',\n): { expr: ColumnRef | OperationExpr; dir: Direction } {\n  return {\n    expr,\n    dir,\n  };\n}\n","import type { BinaryExpr, BinaryOp, ExistsExpr, Expression, ParamRef, SelectAst } from './types';\n\nexport function createBinaryExpr(\n  op: BinaryOp,\n  left: Expression,\n  right: Expression | ParamRef,\n): BinaryExpr {\n  return {\n    kind: 'bin',\n    op,\n    left,\n    right,\n  };\n}\n\nexport function createExistsExpr(not: boolean, subquery: SelectAst): ExistsExpr {\n  return {\n    kind: 'exists',\n    not,\n    subquery,\n  };\n}\n","import type {\n  BinaryExpr,\n  ColumnRef,\n  Direction,\n  ExistsExpr,\n  IncludeAst,\n  IncludeRef,\n  JoinAst,\n  OperationExpr,\n  SelectAst,\n  TableRef,\n} from './types';\nimport { compact } from './util';\n\nexport interface CreateSelectAstOptions {\n  readonly from: TableRef;\n  readonly joins?: ReadonlyArray<JoinAst>;\n  readonly includes?: ReadonlyArray<IncludeAst>;\n  readonly project: ReadonlyArray<{\n    alias: string;\n    expr: ColumnRef | IncludeRef | OperationExpr;\n  }>;\n  readonly where?: BinaryExpr | ExistsExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;\n  readonly limit?: number;\n}\n\nexport function createSelectAst(options: CreateSelectAstOptions): SelectAst {\n  return compact({\n    kind: 'select',\n    from: options.from,\n    joins: options.joins,\n    includes: options.includes,\n    project: options.project,\n    where: options.where,\n    orderBy: options.orderBy,\n    limit: options.limit,\n  }) as SelectAst;\n}\n","import type { ReturnSpec } from '@prisma-next/operations';\nimport type { SqlLoweringSpec } from '@prisma-next/sql-operations';\n\n// SQL-specific AST types and supporting types\n// These types are needed by adapters and runtime for SQL query execution\n\nexport type Direction = 'asc' | 'desc';\n\nexport interface TableRef {\n  readonly kind: 'table';\n  readonly name: string;\n}\n\nexport interface ColumnRef {\n  readonly kind: 'col';\n  readonly table: string;\n  readonly column: string;\n}\n\nexport interface ParamRef {\n  readonly kind: 'param';\n  readonly index: number;\n  readonly name?: string;\n}\n\nexport interface LiteralExpr {\n  readonly kind: 'literal';\n  readonly value: unknown;\n}\n\nexport interface OperationExpr {\n  readonly kind: 'operation';\n  readonly method: string;\n  readonly forTypeId: string;\n  readonly self: Expression;\n  readonly args: ReadonlyArray<Expression | ParamRef | LiteralExpr>;\n  readonly returns: ReturnSpec;\n  readonly lowering: SqlLoweringSpec;\n}\n\n/**\n * Unified expression type - the canonical AST representation for column references\n * and operation expressions. This is what all builders convert to via toExpr().\n */\nexport type Expression = ColumnRef | OperationExpr;\n\n/**\n * Interface for any builder that can produce an Expression.\n * Implemented by ColumnBuilder and ExpressionBuilder.\n */\nexport interface ExpressionSource {\n  toExpr(): Expression;\n}\n\nexport function isOperationExpr(expr: Expression): expr is OperationExpr {\n  return expr.kind === 'operation';\n}\n\nexport type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';\n\nexport interface BinaryExpr {\n  readonly kind: 'bin';\n  readonly op: BinaryOp;\n  readonly left: Expression;\n  readonly right: Expression | ParamRef;\n}\n\nexport interface ExistsExpr {\n  readonly kind: 'exists';\n  readonly not: boolean;\n  readonly subquery: SelectAst;\n}\n\nexport type JoinOnExpr = {\n  readonly kind: 'eqCol';\n  readonly left: ColumnRef;\n  readonly right: ColumnRef;\n};\n\nexport interface JoinAst {\n  readonly kind: 'join';\n  readonly joinType: 'inner' | 'left' | 'right' | 'full';\n  readonly table: TableRef;\n  readonly on: JoinOnExpr;\n}\n\nexport interface IncludeRef {\n  readonly kind: 'includeRef';\n  readonly alias: string;\n}\n\nexport interface IncludeAst {\n  readonly kind: 'includeMany';\n  readonly alias: string;\n  readonly child: {\n    readonly table: TableRef;\n    readonly on: JoinOnExpr;\n    readonly where?: BinaryExpr | ExistsExpr;\n    readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n    readonly limit?: number;\n    readonly project: ReadonlyArray<{ alias: string; expr: Expression }>;\n  };\n}\n\nexport interface SelectAst {\n  readonly kind: 'select';\n  readonly from: TableRef;\n  readonly joins?: ReadonlyArray<JoinAst>;\n  readonly includes?: ReadonlyArray<IncludeAst>;\n  readonly project: ReadonlyArray<{\n    alias: string;\n    expr: Expression | IncludeRef | LiteralExpr;\n  }>;\n  readonly where?: BinaryExpr | ExistsExpr;\n  readonly orderBy?: ReadonlyArray<{ expr: Expression; dir: Direction }>;\n  readonly limit?: number;\n}\n\nexport interface InsertAst {\n  readonly kind: 'insert';\n  readonly table: TableRef;\n  readonly values: Record<string, ColumnRef | ParamRef>;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface UpdateAst {\n  readonly kind: 'update';\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport interface DeleteAst {\n  readonly kind: 'delete';\n  readonly table: TableRef;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport type QueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst;\n\nexport interface LoweredStatement {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n  readonly annotations?: Record<string, unknown>;\n}\n","import type { BinaryExpr, ColumnRef, ParamRef, TableRef, UpdateAst } from './types';\nimport { compact } from './util';\n\nexport interface CreateUpdateAstOptions {\n  readonly table: TableRef;\n  readonly set: Record<string, ColumnRef | ParamRef>;\n  readonly where: BinaryExpr;\n  readonly returning?: ReadonlyArray<ColumnRef>;\n}\n\nexport function createUpdateAst(options: CreateUpdateAstOptions): UpdateAst {\n  return compact({\n    kind: 'update',\n    table: options.table,\n    set: options.set,\n    where: options.where,\n    returning: options.returning,\n  }) as UpdateAst;\n}\n"],"mappings":"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"}

package/dist/exports/errors.d.mts

@@ -0,0 +1,2 @@
+import { n as planUnsupported, t as planInvalid } from "../errors-CLx1Ylq0.mjs";
+export { planInvalid, planUnsupported };

package/dist/exports/errors.mjs

@@ -0,0 +1,3 @@
+import { n as planUnsupported, t as planInvalid } from "../errors-BwxypN2Q.mjs";
+
+export { planInvalid, planUnsupported };

package/dist/exports/guards.d.mts

@@ -0,0 +1,88 @@
+import "../query-lane-context-wr_XXnB5.mjs";
+import { a as ColumnRef, g as LiteralExpr, l as Expression, u as ExpressionSource, v as OperationExpr, y as ParamRef } from "../plan-9PvH-Tu3.mjs";
+import { A as ParamPlaceholder, U as ValueSource, i as AnyExpressionSource, m as ExpressionBuilder, n as AnyColumnBuilder } from "../types-Bg2kUmUA.mjs";
+import { StorageColumn } from "@prisma-next/sql-contract/types";
+
+//#region src/utils/guards.d.ts
+
+/**
+ * Helper to extract columnMeta from a ColumnBuilder or ExpressionBuilder.
+ * Returns StorageColumn if present, undefined otherwise.
+ * Both ColumnBuilder and ExpressionBuilder have columnMeta property.
+ */
+declare function getColumnMeta(expr: AnyExpressionSource): StorageColumn | undefined;
+/**
+ * Type predicate to check if a value is a ParamPlaceholder.
+ */
+declare function isParamPlaceholder(value: unknown): value is ParamPlaceholder;
+/**
+ * Recursively extracts the base ColumnRef from an OperationExpr.
+ * If the expression is already a ColumnRef, it is returned directly.
+ */
+declare function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef;
+/**
+ * Recursively collects all ColumnRef nodes from an expression tree.
+ * Handles nested OperationExpr structures by traversing both self and args.
+ */
+declare function collectColumnRefs(expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr): ColumnRef[];
+/**
+ * Type predicate to check if an expression is an OperationExpr.
+ */
+declare function isOperationExpr(expr: AnyExpressionSource | OperationExpr | Expression): expr is OperationExpr;
+/**
+ * Helper to extract table and column from a ColumnBuilder, ExpressionBuilder, or OperationExpr.
+ * For ExpressionBuilder or OperationExpr, recursively unwraps to find the base ColumnRef.
+ */
+declare function getColumnInfo(expr: AnyExpressionSource | OperationExpr): {
+  table: string;
+  column: string;
+};
+/**
+ * Type predicate to check if a value is a ColumnBuilder.
+ */
+declare function isColumnBuilder(value: unknown): value is AnyColumnBuilder;
+/**
+ * Type predicate to check if a value is an ExpressionBuilder.
+ */
+declare function isExpressionBuilder(value: unknown): value is ExpressionBuilder;
+/**
+ * Type predicate to check if a value is an ExpressionSource (has toExpr method).
+ */
+declare function isExpressionSource(value: unknown): value is ExpressionSource;
+/**
+ * Converts any ExpressionSource to an Expression.
+ * This is the canonical way to get an AST Expression from a builder.
+ *
+ * @param source - A ColumnBuilder or ExpressionBuilder
+ * @returns The corresponding Expression (ColumnRef or OperationExpr)
+ */
+declare function toExpression(source: ExpressionSource): Expression;
+/**
+ * Converts an AnyExpressionSource to an Expression.
+ * Handles both ColumnBuilder and ExpressionBuilder.
+ *
+ * @param source - A ColumnBuilder or ExpressionBuilder
+ * @returns The corresponding Expression (ColumnRef or OperationExpr)
+ */
+declare function expressionFromSource(source: AnyExpressionSource): Expression;
+/**
+ * Type predicate to check if a value is a ValueSource.
+ * ValueSource is either a ParamPlaceholder or an ExpressionSource.
+ */
+declare function isValueSource(value: unknown): value is ValueSource;
+/**
+ * Extracts and returns an OperationExpr from a builder.
+ * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,
+ * otherwise returns undefined.
+ *
+ * @deprecated Use isExpressionBuilder() instead. This function exists for backward compatibility
+ * with code that uses the hidden _operationExpr property pattern.
+ *
+ * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.
+ * The ExpressionBuilder type (introduced in the operation-expr-refactoring) provides a cleaner
+ * approach by explicitly representing operation results as a distinct type.
+ */
+declare function getOperationExpr(builder: AnyColumnBuilder | OperationExpr): OperationExpr | undefined;
+//#endregion
+export { collectColumnRefs, expressionFromSource, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder, isValueSource, toExpression };
+//# sourceMappingURL=guards.d.mts.map

package/dist/exports/guards.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.mts","names":[],"sources":["../../src/utils/guards.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAsBA;AAYA;AAegB,iBA3BA,aAAA,CA2BoB,IAAA,EA3BA,mBA2BA,CAAA,EA3BsB,aA2BtB,GAAA,SAAA;;;;AAA4C,iBAfhE,kBAAA,CAegE,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAfnB,gBAemB;AAWhF;;;;AAC6C,iBAZ7B,oBAAA,CAY6B,IAAA,EAZF,SAYE,GAZU,aAYV,CAAA,EAZ0B,SAY1B;;;AAkB7C;;AAC8B,iBApBd,iBAAA,CAoBc,IAAA,EAnBtB,SAmBsB,GAnBV,QAmBU,GAnBC,WAmBD,GAnBe,aAmBf,CAAA,EAlB3B,SAkB2B,EAAA;;;;AASd,iBAVA,eAAA,CAUoB,IAAA,EAT5B,mBASkD,GAT5B,aASyC,GATzB,UASyB,CAAA,EAAA,IAAA,IAR5D,aAQ4D;AAoBvE;AAYA;AAYA;AAgBA;AAWgB,iBAvEA,aAAA,CAuEoB,IAAS,EAvET,mBAuE+B,GAvET,aAuEmB,CAAA,EAAA;EAQ7D,KAAA,EAAA,MAAA;EAgBA,MAAA,EAAA,MAAA;CACL;;;;iBA5EK,eAAA,2BAA0C;;;;iBAY1C,mBAAA,2BAA8C;;;;iBAY9C,kBAAA,2BAA6C;;;;;;;;iBAgB7C,YAAA,SAAqB,mBAAmB;;;;;;;;iBAWxC,oBAAA,SAA6B,sBAAsB;;;;;iBAQnD,aAAA,2BAAwC;;;;;;;;;;;;;iBAgBxC,gBAAA,UACL,mBAAmB,gBAC3B"}

package/dist/exports/guards.mjs

@@ -0,0 +1,3 @@
+import { a as getColumnMeta, c as isExpressionBuilder, d as isParamPlaceholder, f as isValueSource, i as getColumnInfo, l as isExpressionSource, n as expressionFromSource, o as getOperationExpr, p as toExpression, r as extractBaseColumnRef, s as isColumnBuilder, t as collectColumnRefs, u as isOperationExpr } from "../guards-4T0IByJo.mjs";
+
+export { collectColumnRefs, expressionFromSource, extractBaseColumnRef, getColumnInfo, getColumnMeta, getOperationExpr, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder, isValueSource, toExpression };

package/dist/exports/operations-registry.d.mts

@@ -0,0 +1,5 @@
+import "../query-lane-context-wr_XXnB5.mjs";
+import "../plan-9PvH-Tu3.mjs";
+import "../types-Bg2kUmUA.mjs";
+import { t as attachOperationsToColumnBuilder } from "../operations-registry-CIcn4f2P.mjs";
+export { attachOperationsToColumnBuilder };

package/dist/exports/operations-registry.mjs

@@ -0,0 +1,3 @@
+import { t as attachOperationsToColumnBuilder } from "../operations-registry-7R5KE2-5.mjs";
+
+export { attachOperationsToColumnBuilder };

package/dist/exports/param.d.mts

@@ -0,0 +1,5 @@
+import "../query-lane-context-wr_XXnB5.mjs";
+import "../plan-9PvH-Tu3.mjs";
+import "../types-Bg2kUmUA.mjs";
+import { n as param, t as Parameter } from "../param-B4LzVPv2.mjs";
+export { Parameter, param };

package/dist/exports/param.mjs

@@ -0,0 +1,3 @@
+import { t as param } from "../param-BFvNAaHR.mjs";
+
+export { param };

package/dist/exports/plan.d.mts

@@ -0,0 +1,2 @@
+import { n as augmentDescriptorWithColumnMeta, t as SqlQueryPlan } from "../plan-9PvH-Tu3.mjs";
+export { SqlQueryPlan, augmentDescriptorWithColumnMeta };

package/dist/exports/plan.mjs

@@ -0,0 +1,17 @@
+//#region src/plan.ts
+/**
+* Augments the last ParamDescriptor in the array with codecId and nativeType from columnMeta.
+* This is used when building WHERE expressions to ensure param descriptors have type information.
+*/
+function augmentDescriptorWithColumnMeta(descriptors, columnMeta) {
+	const descriptor = descriptors[descriptors.length - 1];
+	if (descriptor && columnMeta) descriptors[descriptors.length - 1] = {
+		...descriptor,
+		codecId: columnMeta.codecId,
+		nativeType: columnMeta.nativeType
+	};
+}
+
+//#endregion
+export { augmentDescriptorWithColumnMeta };
+//# sourceMappingURL=plan.mjs.map