@prisma-next/sql-relational-core 0.3.0-dev.5 → 0.3.0-dev.50

package/dist/operations-registry-DPZ5aElH.mjs

@@ -0,0 +1,152 @@
+import { d as isParamPlaceholder } from "./guards-0ycyntYX.mjs";
+import { planInvalid } from "@prisma-next/plan";
+import { hasAllCapabilities } from "@prisma-next/operations";
+
+//#region src/operations-registry.ts
+/**
+* Type guard to check if a value is an ExpressionSource (has toExpr method).
+*/
+function isExpressionSource(value) {
+	return typeof value === "object" && value !== null && "toExpr" in value && typeof value.toExpr === "function";
+}
+/**
+* Executes an operation and returns an ExpressionBuilder.
+* This is the canonical entrypoint for operation invocation, enabling
+* future enhancements like telemetry, caching, or tracing.
+*
+* The returned ExpressionBuilder:
+* - Has `kind: 'expression'` to distinguish it from ColumnBuilder
+* - Contains the operation expression in `expr`
+* - Provides `toExpr()` method to get the Expression
+* - Provides comparison and ordering methods for chaining
+*
+* @param signature - The operation signature from the registry
+* @param selfBuilder - The expression source that the operation is called on
+* @param args - The arguments passed to the operation
+* @param columnMeta - The metadata of the column the operation is called on
+* @returns An ExpressionBuilder containing the operation expression
+*/
+function executeOperation(signature, selfBuilder, args, columnMeta, operationRegistry, contractCapabilities) {
+	if (args.length !== signature.args.length) throw planInvalid(`Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`);
+	const selfExpr = selfBuilder.toExpr();
+	const operationArgs = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		const argSpec = signature.args[i];
+		if (!argSpec) throw planInvalid(`Missing argument spec for argument ${i}`);
+		if (argSpec.kind === "param") {
+			if (!isParamPlaceholder(arg)) throw planInvalid(`Argument ${i} must be a parameter placeholder`);
+			operationArgs.push({
+				kind: "param",
+				index: 0,
+				name: arg.name
+			});
+		} else if (argSpec.kind === "typeId") {
+			if (!isExpressionSource(arg)) throw planInvalid(`Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`);
+			operationArgs.push(arg.toExpr());
+		} else if (argSpec.kind === "literal") operationArgs.push({
+			kind: "literal",
+			value: arg
+		});
+	}
+	const operationExpr = {
+		kind: "operation",
+		method: signature.method,
+		forTypeId: signature.forTypeId,
+		self: selfExpr,
+		args: operationArgs,
+		returns: signature.returns,
+		lowering: signature.lowering
+	};
+	const returnTypeId = signature.returns.kind === "typeId" ? signature.returns.type : void 0;
+	const returnColumnMeta = returnTypeId ? {
+		...columnMeta,
+		codecId: returnTypeId
+	} : columnMeta;
+	const createComparisonMethod = (op) => (value) => Object.freeze({
+		kind: "binary",
+		op,
+		left: operationExpr,
+		right: value
+	});
+	const baseResult = {
+		kind: "expression",
+		expr: operationExpr,
+		get columnMeta() {
+			return returnColumnMeta;
+		},
+		eq: createComparisonMethod("eq"),
+		neq: createComparisonMethod("neq"),
+		gt: createComparisonMethod("gt"),
+		lt: createComparisonMethod("lt"),
+		gte: createComparisonMethod("gte"),
+		lte: createComparisonMethod("lte"),
+		asc() {
+			return Object.freeze({
+				kind: "order",
+				expr: operationExpr,
+				dir: "asc"
+			});
+		},
+		desc() {
+			return Object.freeze({
+				kind: "order",
+				expr: operationExpr,
+				dir: "desc"
+			});
+		},
+		toExpr() {
+			return operationExpr;
+		},
+		get __jsType() {}
+	};
+	if (returnTypeId && operationRegistry) {
+		const resultWithOps = attachOperationsToExpressionBuilder(baseResult, returnColumnMeta, operationRegistry, contractCapabilities);
+		return Object.freeze(resultWithOps);
+	}
+	return Object.freeze(baseResult);
+}
+/**
+* Attaches operation methods to an ExpressionBuilder for chained operations.
+* When an operation returns a typeId, the result ExpressionBuilder needs
+* operation methods for that type.
+*/
+function attachOperationsToExpressionBuilder(expressionBuilder, columnMeta, registry, contractCapabilities) {
+	const codecId = columnMeta.codecId;
+	if (!codecId) return expressionBuilder;
+	const operations = registry.byType(codecId);
+	if (operations.length === 0) return expressionBuilder;
+	const builderWithOps = expressionBuilder;
+	for (const operation of operations) {
+		if (operation.capabilities && operation.capabilities.length > 0) {
+			if (!contractCapabilities) continue;
+			if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) continue;
+		}
+		builderWithOps[operation.method] = function(...args) {
+			return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);
+		};
+	}
+	return builderWithOps;
+}
+function attachOperationsToColumnBuilder(columnBuilder, columnMeta, registry, contractCapabilities) {
+	if (!registry) return columnBuilder;
+	const codecId = columnMeta.codecId;
+	if (!codecId) return columnBuilder;
+	const operations = registry.byType(codecId);
+	if (operations.length === 0) return columnBuilder;
+	const builderWithOps = columnBuilder;
+	for (const operation of operations) {
+		if (operation.capabilities && operation.capabilities.length > 0) {
+			if (!contractCapabilities) continue;
+			if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) continue;
+		}
+		builderWithOps[operation.method] = function(...args) {
+			return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);
+		};
+	}
+	return builderWithOps;
+}
+
+//#endregion
+export { attachOperationsToColumnBuilder as t };
+//# sourceMappingURL=operations-registry-DPZ5aElH.mjs.map

package/dist/operations-registry-DPZ5aElH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry-DPZ5aElH.mjs","names":["selfExpr: Expression","operationArgs: Array<Expression | ParamRef | LiteralExpr>","operationExpr: OperationExpr","returnColumnMeta: StorageColumn","baseResult: ExpressionBuilder"],"sources":["../src/operations-registry.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport { hasAllCapabilities } from '@prisma-next/operations';\nimport { planInvalid } from '@prisma-next/plan';\nimport type { StorageColumn } from '@prisma-next/sql-contract/types';\nimport type { SqlOperationSignature } from '@prisma-next/sql-operations';\nimport type {\n  BinaryOp,\n  Expression,\n  ExpressionSource,\n  LiteralExpr,\n  OperationExpr,\n  ParamRef,\n} from './ast/types';\nimport type {\n  AnyBinaryBuilder,\n  AnyOrderBuilder,\n  ColumnBuilder,\n  ExpressionBuilder,\n  OperationTypes,\n  ParamPlaceholder,\n} from './types';\nimport { isParamPlaceholder } from './utils/guards';\n\n/**\n * Type guard to check if a value is an ExpressionSource (has toExpr method).\n */\nfunction isExpressionSource(value: unknown): value is ExpressionSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof (value as ExpressionSource).toExpr === 'function'\n  );\n}\n\n/**\n * Executes an operation and returns an ExpressionBuilder.\n * This is the canonical entrypoint for operation invocation, enabling\n * future enhancements like telemetry, caching, or tracing.\n *\n * The returned ExpressionBuilder:\n * - Has `kind: 'expression'` to distinguish it from ColumnBuilder\n * - Contains the operation expression in `expr`\n * - Provides `toExpr()` method to get the Expression\n * - Provides comparison and ordering methods for chaining\n *\n * @param signature - The operation signature from the registry\n * @param selfBuilder - The expression source that the operation is called on\n * @param args - The arguments passed to the operation\n * @param columnMeta - The metadata of the column the operation is called on\n * @returns An ExpressionBuilder containing the operation expression\n */\nfunction executeOperation(\n  signature: SqlOperationSignature,\n  selfBuilder: ExpressionSource,\n  args: unknown[],\n  columnMeta: StorageColumn,\n  operationRegistry?: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  if (args.length !== signature.args.length) {\n    throw planInvalid(\n      `Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`,\n    );\n  }\n\n  // Get the Expression from the self builder using toExpr()\n  const selfExpr: Expression = selfBuilder.toExpr();\n\n  const operationArgs: Array<Expression | ParamRef | LiteralExpr> = [];\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n    const argSpec = signature.args[i];\n    if (!argSpec) {\n      throw planInvalid(`Missing argument spec for argument ${i}`);\n    }\n\n    if (argSpec.kind === 'param') {\n      if (!isParamPlaceholder(arg)) {\n        throw planInvalid(`Argument ${i} must be a parameter placeholder`);\n      }\n      operationArgs.push({\n        kind: 'param',\n        index: 0,\n        name: arg.name,\n      });\n    } else if (argSpec.kind === 'typeId') {\n      // Accept ExpressionSource (ColumnBuilder or ExpressionBuilder)\n      if (!isExpressionSource(arg)) {\n        throw planInvalid(\n          `Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`,\n        );\n      }\n      // Use toExpr() to get the Expression\n      operationArgs.push(arg.toExpr());\n    } else if (argSpec.kind === 'literal') {\n      operationArgs.push({\n        kind: 'literal',\n        value: arg,\n      });\n    }\n  }\n\n  const operationExpr: OperationExpr = {\n    kind: 'operation',\n    method: signature.method,\n    forTypeId: signature.forTypeId,\n    self: selfExpr,\n    args: operationArgs,\n    returns: signature.returns,\n    lowering: signature.lowering,\n  };\n\n  const returnTypeId = signature.returns.kind === 'typeId' ? signature.returns.type : undefined;\n  const returnColumnMeta: StorageColumn = returnTypeId\n    ? {\n        ...columnMeta,\n        codecId: returnTypeId,\n      }\n    : columnMeta;\n\n  const createComparisonMethod =\n    (op: BinaryOp) =>\n    (value: ParamPlaceholder | ExpressionSource): AnyBinaryBuilder =>\n      Object.freeze({\n        kind: 'binary' as const,\n        op,\n        left: operationExpr,\n        right: value,\n      }) as AnyBinaryBuilder;\n\n  const baseResult: ExpressionBuilder = {\n    kind: 'expression' as const,\n    expr: operationExpr,\n    get columnMeta() {\n      return returnColumnMeta;\n    },\n    eq: createComparisonMethod('eq'),\n    neq: createComparisonMethod('neq'),\n    gt: createComparisonMethod('gt'),\n    lt: createComparisonMethod('lt'),\n    gte: createComparisonMethod('gte'),\n    lte: createComparisonMethod('lte'),\n    asc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'asc' as const,\n      });\n    },\n    desc(): AnyOrderBuilder {\n      return Object.freeze({\n        kind: 'order' as const,\n        expr: operationExpr,\n        dir: 'desc' as const,\n      });\n    },\n    toExpr(): OperationExpr {\n      return operationExpr;\n    },\n    get __jsType(): unknown {\n      return undefined;\n    },\n  };\n\n  // If the return type is a typeId, attach operations for that type\n  if (returnTypeId && operationRegistry) {\n    const resultWithOps = attachOperationsToExpressionBuilder(\n      baseResult,\n      returnColumnMeta,\n      operationRegistry,\n      contractCapabilities,\n    );\n    return Object.freeze(resultWithOps);\n  }\n\n  return Object.freeze(baseResult);\n}\n\n/**\n * Attaches operation methods to an ExpressionBuilder for chained operations.\n * When an operation returns a typeId, the result ExpressionBuilder needs\n * operation methods for that type.\n */\nfunction attachOperationsToExpressionBuilder(\n  expressionBuilder: ExpressionBuilder,\n  columnMeta: StorageColumn,\n  registry: OperationRegistry,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ExpressionBuilder {\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return expressionBuilder;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return expressionBuilder;\n  }\n\n  const builderWithOps = expressionBuilder as ExpressionBuilder & Record<string, unknown>;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the expression builder\n    builderWithOps[operation.method] = function (this: ExpressionBuilder, ...args: unknown[]) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n\nexport function attachOperationsToColumnBuilder<\n  ColumnName extends string,\n  ColumnMeta extends StorageColumn,\n  JsType = unknown,\n  Operations extends OperationTypes = Record<string, never>,\n>(\n  columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n  columnMeta: ColumnMeta,\n  registry: OperationRegistry | undefined,\n  contractCapabilities?: Record<string, Record<string, boolean>>,\n): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations> {\n  if (!registry) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  // Use codecId to look up operations registered for this column's type\n  const codecId = columnMeta.codecId;\n  if (!codecId) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const operations = registry.byType(codecId) as SqlOperationSignature[];\n  if (operations.length === 0) {\n    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;\n  }\n\n  const builderWithOps = columnBuilder as unknown as ColumnBuilder<\n    ColumnName,\n    ColumnMeta,\n    JsType,\n    Operations\n  >;\n\n  for (const operation of operations) {\n    if (operation.capabilities && operation.capabilities.length > 0) {\n      if (!contractCapabilities) {\n        continue;\n      }\n\n      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {\n        continue;\n      }\n    }\n    // Method sugar: attach operation as a method on the column builder\n    // Operations return ExpressionBuilder, not ColumnBuilder\n    (builderWithOps as Record<string, unknown>)[operation.method] = function (\n      this: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,\n      ...args: unknown[]\n    ) {\n      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);\n    };\n  }\n\n  return builderWithOps;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { A as OperationTypes, d as ColumnBuilder } from "./types-CEUzDuDC.mjs";
+import { OperationRegistry } from "@prisma-next/operations";
+import { StorageColumn } from "@prisma-next/sql-contract/types";
+
+//#region src/operations-registry.d.ts
+declare function attachOperationsToColumnBuilder<ColumnName extends string, ColumnMeta extends StorageColumn, JsType = unknown, Operations extends OperationTypes = Record<string, never>>(columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>, columnMeta: ColumnMeta, registry: OperationRegistry | undefined, contractCapabilities?: Record<string, Record<string, boolean>>): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
+//#endregion
+export { attachOperationsToColumnBuilder as t };
+//# sourceMappingURL=operations-registry-wVEaiLyt.d.mts.map

package/dist/operations-registry-wVEaiLyt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations-registry-wVEaiLyt.d.mts","names":[],"sources":["../src/operations-registry.ts"],"sourcesContent":[],"mappings":";;;;;iBA6NgB,8EAEK,oDAEA,iBAAiB,sCAErB,cAAc,YAAY,YAAY,QAAQ,oCACjD,sBACF,sDACa,eAAe,2BACrC,cAAc,YAAY,YAAY,QAAQ"}

package/dist/param-C4n0OW59.d.mts

@@ -0,0 +1,8 @@
+import { N as ParamPlaceholder } from "./types-CEUzDuDC.mjs";
+
+//#region src/param.d.ts
+type Parameter = ParamPlaceholder;
+declare function param(name: string): Parameter;
+//#endregion
+export { param as n, Parameter as t };
+//# sourceMappingURL=param-C4n0OW59.d.mts.map

package/dist/param-C4n0OW59.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-C4n0OW59.d.mts","names":[],"sources":["../src/param.ts"],"sourcesContent":[],"mappings":";;;KAGY,SAAA,GAAY;iBAER,KAAA,gBAAqB"}

package/dist/param-DMU3OWfI.mjs

@@ -0,0 +1,14 @@
+import { planInvalid } from "@prisma-next/plan";
+
+//#region src/param.ts
+function param(name) {
+	if (typeof name !== "string" || name.length === 0) throw planInvalid("Parameter name must be a non-empty string");
+	return Object.freeze({
+		kind: "param-placeholder",
+		name
+	});
+}
+
+//#endregion
+export { param as t };
+//# sourceMappingURL=param-DMU3OWfI.mjs.map

package/dist/param-DMU3OWfI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"param-DMU3OWfI.mjs","names":[],"sources":["../src/param.ts"],"sourcesContent":["import { planInvalid } from '@prisma-next/plan';\nimport type { ParamPlaceholder } from './types';\n\nexport type Parameter = ParamPlaceholder;\n\nexport function param(name: string): Parameter {\n  if (typeof name !== 'string' || name.length === 0) {\n    throw planInvalid('Parameter name must be a non-empty string');\n  }\n\n  return Object.freeze({\n    kind: 'param-placeholder' as const,\n    name,\n  }) satisfies Parameter;\n}\n"],"mappings":";;;AAKA,SAAgB,MAAM,MAAyB;AAC7C,KAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAC9C,OAAM,YAAY,4CAA4C;AAGhE,QAAO,OAAO,OAAO;EACnB,MAAM;EACN;EACD,CAAC"}

package/dist/plan-BhSWuTfw.d.mts

@@ -0,0 +1,194 @@
+import { ReturnSpec } from "@prisma-next/operations";
+import { ExecutionPlan, ParamDescriptor } from "@prisma-next/contract/types";
+import { SqlLoweringSpec } from "@prisma-next/sql-operations";
+import { StorageColumn } from "@prisma-next/sql-contract/types";
+
+//#region src/ast/types.d.ts
+type Direction = 'asc' | 'desc';
+interface TableRef {
+  readonly kind: 'table';
+  readonly name: string;
+}
+interface ColumnRef {
+  readonly kind: 'col';
+  readonly table: string;
+  readonly column: string;
+}
+interface ParamRef {
+  readonly kind: 'param';
+  readonly index: number;
+  readonly name?: string;
+}
+interface LiteralExpr {
+  readonly kind: 'literal';
+  readonly value: unknown;
+}
+interface OperationExpr {
+  readonly kind: 'operation';
+  readonly method: string;
+  readonly forTypeId: string;
+  readonly self: Expression;
+  readonly args: ReadonlyArray<Expression | ParamRef | LiteralExpr>;
+  readonly returns: ReturnSpec;
+  readonly lowering: SqlLoweringSpec;
+}
+/**
+ * Unified expression type - the canonical AST representation for column references
+ * and operation expressions. This is what all builders convert to via toExpr().
+ */
+type Expression = ColumnRef | OperationExpr;
+/**
+ * Interface for any builder that can produce an Expression.
+ * Implemented by ColumnBuilder and ExpressionBuilder.
+ */
+interface ExpressionSource {
+  toExpr(): Expression;
+}
+declare function isOperationExpr(expr: Expression): expr is OperationExpr;
+type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'ilike' | 'in' | 'notIn';
+interface BinaryExpr {
+  readonly kind: 'bin';
+  readonly op: BinaryOp;
+  readonly left: Expression;
+  readonly right: Expression | ParamRef | LiteralExpr | ListLiteralExpr;
+}
+interface ListLiteralExpr {
+  readonly kind: 'listLiteral';
+  readonly values: ReadonlyArray<ParamRef | LiteralExpr>;
+}
+interface AndExpr {
+  readonly kind: 'and';
+  readonly exprs: ReadonlyArray<WhereExpr>;
+}
+interface OrExpr {
+  readonly kind: 'or';
+  readonly exprs: ReadonlyArray<WhereExpr>;
+}
+interface ExistsExpr {
+  readonly kind: 'exists';
+  readonly not: boolean;
+  readonly subquery: SelectAst;
+}
+/**
+ * Unary expression for IS NULL / IS NOT NULL checks.
+ * Used in WHERE clauses to check for null values.
+ */
+interface NullCheckExpr {
+  readonly kind: 'nullCheck';
+  readonly expr: Expression;
+  readonly isNull: boolean;
+}
+/**
+ * Union type for WHERE clause expressions.
+ */
+type WhereExpr = BinaryExpr | ExistsExpr | NullCheckExpr | AndExpr | OrExpr;
+interface BoundWhereExpr {
+  readonly expr: WhereExpr;
+  readonly params: readonly unknown[];
+  readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;
+}
+interface ToWhereExpr {
+  toWhereExpr(): BoundWhereExpr;
+}
+type WhereArg = WhereExpr | ToWhereExpr;
+type JoinOnExpr = {
+  readonly kind: 'eqCol';
+  readonly left: ColumnRef;
+  readonly right: ColumnRef;
+} | WhereExpr;
+interface JoinAst {
+  readonly kind: 'join';
+  readonly joinType: 'inner' | 'left' | 'right' | 'full';
+  readonly table: TableRef;
+  readonly on: JoinOnExpr;
+}
+interface IncludeRef {
+  readonly kind: 'includeRef';
+  readonly alias: string;
+}
+interface IncludeAst {
+  readonly kind: 'includeMany';
+  readonly alias: string;
+  readonly child: {
+    readonly table: TableRef;
+    readonly on: JoinOnExpr;
+    readonly where?: WhereExpr;
+    readonly orderBy?: ReadonlyArray<{
+      expr: Expression;
+      dir: Direction;
+    }>;
+    readonly limit?: number;
+    readonly project: ReadonlyArray<{
+      alias: string;
+      expr: Expression;
+    }>;
+  };
+}
+interface SelectAst {
+  readonly kind: 'select';
+  readonly from: TableRef;
+  readonly joins?: ReadonlyArray<JoinAst>;
+  readonly includes?: ReadonlyArray<IncludeAst>;
+  readonly project: ReadonlyArray<{
+    alias: string;
+    expr: Expression | IncludeRef | LiteralExpr;
+  }>;
+  readonly where?: WhereExpr;
+  readonly orderBy?: ReadonlyArray<{
+    expr: Expression;
+    dir: Direction;
+  }>;
+  readonly limit?: number;
+  readonly selectAllIntent?: {
+    table?: string;
+  };
+}
+interface InsertAst {
+  readonly kind: 'insert';
+  readonly table: TableRef;
+  readonly values: Record<string, ColumnRef | ParamRef>;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+interface UpdateAst {
+  readonly kind: 'update';
+  readonly table: TableRef;
+  readonly set: Record<string, ColumnRef | ParamRef>;
+  readonly where?: WhereExpr;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+interface DeleteAst {
+  readonly kind: 'delete';
+  readonly table: TableRef;
+  readonly where?: WhereExpr;
+  readonly returning?: ReadonlyArray<ColumnRef>;
+}
+type QueryAst = SelectAst | InsertAst | UpdateAst | DeleteAst;
+interface LoweredStatement {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+  readonly annotations?: Record<string, unknown>;
+}
+//#endregion
+//#region src/plan.d.ts
+/**
+ * SQL query plan produced by lanes before lowering.
+ *
+ * Lanes build ASTs and metadata but do not perform SQL lowering.
+ * The `sql` field is absent - lowering happens in the runtime executor.
+ *
+ * Structurally aligns with ExecutionPlan<Row, QueryAst> (without sql field) to maintain
+ * compatibility with ExecutionPlan/Plan-based utilities.
+ * The generic parameter `_Row` is preserved for type extraction via ResultType.
+ */
+interface SqlQueryPlan<_Row = unknown> extends Pick<ExecutionPlan<_Row, QueryAst>, 'params' | 'meta'> {
+  readonly ast: QueryAst;
+  readonly _Row?: _Row;
+}
+/**
+ * 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.
+ */
+declare function augmentDescriptorWithColumnMeta(descriptors: ParamDescriptor[], columnMeta: StorageColumn | undefined): void;
+//#endregion
+export { WhereArg as A, OrExpr as C, TableRef as D, SelectAst as E, isOperationExpr as M, ToWhereExpr as O, OperationExpr as S, QueryAst as T, JoinOnExpr as _, BinaryOp as a, LoweredStatement as b, DeleteAst as c, Expression as d, ExpressionSource as f, JoinAst as g, InsertAst as h, BinaryExpr as i, WhereExpr as j, UpdateAst as k, Direction as l, IncludeRef as m, augmentDescriptorWithColumnMeta as n, BoundWhereExpr as o, IncludeAst as p, AndExpr as r, ColumnRef as s, SqlQueryPlan as t, ExistsExpr as u, ListLiteralExpr as v, ParamRef as w, NullCheckExpr as x, LiteralExpr as y };
+//# sourceMappingURL=plan-BhSWuTfw.d.mts.map

package/dist/plan-BhSWuTfw.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-BhSWuTfw.d.mts","names":[],"sources":["../src/ast/types.ts","../src/plan.ts"],"sourcesContent":[],"mappings":"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"}