@prisma-next/sql-relational-core 0.5.0-dev.4 → 0.5.0-dev.41

package/dist/exports/ast.mjs

@@ -1,3 +1,4 @@
+import { A as UpdateAst, C as OrExpr, D as SelectAst, E as ProjectionItem, M as isWhereExpr, N as queryAstKinds, O as SubqueryExpr, P as whereExprKinds, S as OperationExpr, T as ParamRef, _ as JsonObjectExpr, a as DefaultValueExpr, b as NotExpr, c as DoNothingConflictAction, d as ExistsExpr, f as IdentifierRef, g as JsonArrayAggExpr, h as JoinAst, i as ColumnRef, j as isQueryAst, k as TableSource, l as DoUpdateSetConflictAction, m as InsertOnConflict, n as AndExpr, o as DeleteAst, p as InsertAst, r as BinaryExpr, s as DerivedTableSource, t as AggregateExpr, u as EqColJoinOn, v as ListExpression, w as OrderByItem, x as NullCheckExpr, y as LiteralExpr } from "../types-DUL-3vy6.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { type } from "arktype";
 
@@ -73,11 +74,25 @@ var CodecRegistryImpl = class {
 	}
 };
 /**
-* Codec factory - creates a codec with typeId and encode/decode functions.
-* Provides identity defaults for encodeJson/decodeJson when not supplied.
+* Construct a SQL codec from author functions and optional metadata.
+*
+* Author `encode` and `decode` as sync or async functions; the factory
+* produces a {@link Codec} whose query-time methods follow the boundary
+* contract documented on `Codec`. Authors receive a second `ctx` options
+* argument carrying the SQL-family per-call context; ignore it if you
+* don't need it.
+*
+* Both `encode` and `decode` are required so `TInput` and `TWire` are
+* always covered by an explicit author function — the factory installs
+* no identity fallback. `encodeJson` and `decodeJson` default to identity
+* **only when `TInput` is assignable to `JsonValue`**; otherwise both are
+* required so the contract artifact stays JSON-safe.
 */
 function codec(config) {
 	const identity = (v) => v;
+	const userEncode = config.encode;
+	const userDecode = config.decode;
+	const widenedConfig = config;
 	return {
 		id: config.typeId,
 		targetTypes: config.targetTypes,
@@ -86,10 +101,22 @@ function codec(config) {
 		...ifDefined("init", config.init),
 		...ifDefined("traits", config.traits ? Object.freeze([...config.traits]) : void 0),
 		...ifDefined("renderOutputType", config.renderOutputType),
-		encode: config.encode,
-		decode: config.decode,
-		encodeJson: config.encodeJson ?? identity,
-		decodeJson: config.decodeJson ?? identity
+		encode: (value, ctx) => {
+			try {
+				return Promise.resolve(userEncode(value, ctx));
+			} catch (error) {
+				return Promise.reject(error);
+			}
+		},
+		decode: (wire, ctx) => {
+			try {
+				return Promise.resolve(userDecode(wire, ctx));
+			} catch (error) {
+				return Promise.reject(error);
+			}
+		},
+		encodeJson: widenedConfig.encodeJson ?? identity,
+		decodeJson: widenedConfig.decodeJson ?? identity
 	};
 }
 /**
@@ -244,8 +271,15 @@ const sqlTimestampCodec = codec({
 	typeId: SQL_TIMESTAMP_CODEC_ID,
 	targetTypes: ["timestamp"],
 	traits: ["equality", "order"],
-	encode: (value) => value instanceof Date ? value.toISOString() : value,
-	decode: (wire) => wire instanceof Date ? wire.toISOString() : wire,
+	encode: (value) => value,
+	decode: (wire) => wire,
+	encodeJson: (value) => value.toISOString(),
+	decodeJson: (json) => {
+		if (typeof json !== "string") throw new Error(`Expected ISO date string for sql/timestamp@1, got ${typeof json}`);
+		const date = new Date(json);
+		if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for sql/timestamp@1: ${json}`);
+		return date;
+	},
 	paramsSchema: precisionParamsSchema,
 	renderOutputType: (typeParams) => {
 		const precision = typeParams["precision"];
@@ -258,1086 +292,6 @@ const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcha
 const sqlCodecDefinitions = codecs.codecDefinitions;
 const sqlDataTypes = codecs.dataTypes;
 
-//#endregion
-//#region src/ast/types.ts
-function frozenArrayCopy(values) {
-	return Object.freeze([...values]);
-}
-function frozenOptionalRecordCopy(value) {
-	return value === void 0 ? void 0 : Object.freeze({ ...value });
-}
-function frozenRecordCopy(record) {
-	return Object.freeze({ ...record });
-}
-function freezeRows(rows) {
-	return Object.freeze(rows.map((row) => Object.freeze({ ...row })));
-}
-function combineAll(folder, thunks) {
-	let result = folder.empty;
-	for (const thunk of thunks) {
-		if (folder.isAbsorbing?.(result)) return result;
-		result = folder.combine(result, thunk());
-	}
-	return result;
-}
-function rewriteComparable(value, rewriter) {
-	switch (value.kind) {
-		case "param-ref": return rewriter.paramRef ? rewriter.paramRef(value) : value;
-		case "literal": return rewriter.literal ? rewriter.literal(value) : value;
-		case "list":
-			if (rewriter.list) return rewriter.list(value);
-			return value.rewrite(rewriter);
-		default: return value.rewrite(rewriter);
-	}
-}
-function foldComparable(value, folder) {
-	switch (value.kind) {
-		case "param-ref": return folder.paramRef ? folder.paramRef(value) : folder.empty;
-		case "literal": return folder.literal ? folder.literal(value) : folder.empty;
-		case "list": return value.fold(folder);
-		default: return value.fold(folder);
-	}
-}
-function collectColumnRefsWith(node) {
-	return node.fold({
-		empty: [],
-		combine: (a, b) => [...a, ...b],
-		columnRef: (columnRef) => [columnRef],
-		select: (ast) => ast.collectColumnRefs()
-	});
-}
-function collectParamRefsWith(node) {
-	return node.fold({
-		empty: [],
-		combine: (a, b) => [...a, ...b],
-		paramRef: (paramRef) => [paramRef],
-		select: (ast) => ast.collectParamRefs()
-	});
-}
-function sortRefs(tables, columns) {
-	return {
-		tables: [...tables].sort((a, b) => a.localeCompare(b)),
-		columns: [...columns.values()].sort((a, b) => {
-			const tableCompare = a.table.localeCompare(b.table);
-			if (tableCompare !== 0) return tableCompare;
-			return a.column.localeCompare(b.column);
-		})
-	};
-}
-function addColumnRefToRefSets(columnRef, tables, columns) {
-	if (columnRef.table === "excluded") return;
-	tables.add(columnRef.table);
-	const key = `${columnRef.table}.${columnRef.column}`;
-	if (!columns.has(key)) columns.set(key, {
-		table: columnRef.table,
-		column: columnRef.column
-	});
-}
-function mergeRefsInto(refs, tables, columns) {
-	for (const table of refs.tables ?? []) tables.add(table);
-	for (const column of refs.columns ?? []) addColumnRefToRefSets(new ColumnRef(column.table, column.column), tables, columns);
-}
-var AstNode = class {
-	freeze() {
-		Object.freeze(this);
-	}
-};
-var QueryAst = class extends AstNode {
-	collectColumnRefs() {
-		return (this.collectRefs().columns ?? []).map((ref) => new ColumnRef(ref.table, ref.column));
-	}
-};
-var FromSource = class extends AstNode {};
-var Expression = class extends AstNode {
-	collectColumnRefs() {
-		return collectColumnRefsWith(this);
-	}
-	collectParamRefs() {
-		return collectParamRefsWith(this);
-	}
-	baseColumnRef() {
-		throw new Error(`${this.constructor.name} does not expose a base column reference`);
-	}
-	toExpr() {
-		return this;
-	}
-	not() {
-		return new NotExpr(this);
-	}
-};
-var TableSource = class TableSource extends FromSource {
-	kind = "table-source";
-	name;
-	alias;
-	constructor(name, alias) {
-		super();
-		this.name = name;
-		this.alias = alias;
-		this.freeze();
-	}
-	static named(name, alias) {
-		return new TableSource(name, alias);
-	}
-	rewrite(rewriter) {
-		return rewriter.tableSource ? rewriter.tableSource(this) : this;
-	}
-	toFromSource() {
-		return this;
-	}
-	collectRefs() {
-		return {
-			tables: [this.name],
-			columns: []
-		};
-	}
-};
-var DerivedTableSource = class DerivedTableSource extends FromSource {
-	kind = "derived-table-source";
-	alias;
-	query;
-	constructor(alias, query) {
-		super();
-		this.alias = alias;
-		this.query = query;
-		this.freeze();
-	}
-	static as(alias, query) {
-		return new DerivedTableSource(alias, query);
-	}
-	rewrite(rewriter) {
-		return new DerivedTableSource(this.alias, this.query.rewrite(rewriter));
-	}
-	toFromSource() {
-		return this;
-	}
-	collectRefs() {
-		return this.query.collectRefs();
-	}
-};
-var ColumnRef = class ColumnRef extends Expression {
-	kind = "column-ref";
-	table;
-	column;
-	constructor(table, column) {
-		super();
-		this.table = table;
-		this.column = column;
-		this.freeze();
-	}
-	static of(table, column) {
-		return new ColumnRef(table, column);
-	}
-	accept(visitor) {
-		return visitor.columnRef(this);
-	}
-	rewrite(rewriter) {
-		return rewriter.columnRef ? rewriter.columnRef(this) : this;
-	}
-	fold(folder) {
-		return folder.columnRef ? folder.columnRef(this) : folder.empty;
-	}
-	baseColumnRef() {
-		return this;
-	}
-};
-var IdentifierRef = class IdentifierRef extends Expression {
-	kind = "identifier-ref";
-	name;
-	constructor(name) {
-		super();
-		this.name = name;
-		this.freeze();
-	}
-	static of(name) {
-		return new IdentifierRef(name);
-	}
-	accept(visitor) {
-		return visitor.identifierRef(this);
-	}
-	rewrite(rewriter) {
-		return rewriter.identifierRef ? rewriter.identifierRef(this) : this;
-	}
-	fold(folder) {
-		return folder.identifierRef ? folder.identifierRef(this) : folder.empty;
-	}
-};
-var ParamRef = class ParamRef extends Expression {
-	kind = "param-ref";
-	value;
-	name;
-	codecId;
-	constructor(value, options) {
-		super();
-		this.value = value;
-		this.name = options?.name;
-		this.codecId = options?.codecId;
-		this.freeze();
-	}
-	static of(value, options) {
-		return new ParamRef(value, options);
-	}
-	accept(visitor) {
-		return visitor.param(this);
-	}
-	rewrite(rewriter) {
-		return rewriter.paramRef ? rewriter.paramRef(this) : this;
-	}
-	fold(folder) {
-		return folder.paramRef ? folder.paramRef(this) : folder.empty;
-	}
-};
-var DefaultValueExpr = class extends AstNode {
-	kind = "default-value";
-	constructor() {
-		super();
-		this.freeze();
-	}
-};
-var LiteralExpr = class LiteralExpr extends Expression {
-	kind = "literal";
-	value;
-	constructor(value) {
-		super();
-		this.value = value;
-		this.freeze();
-	}
-	static of(value) {
-		return new LiteralExpr(value);
-	}
-	accept(visitor) {
-		return visitor.literal(this);
-	}
-	rewrite(rewriter) {
-		return rewriter.literal ? rewriter.literal(this) : this;
-	}
-	fold(folder) {
-		return folder.literal ? folder.literal(this) : folder.empty;
-	}
-};
-var SubqueryExpr = class SubqueryExpr extends Expression {
-	kind = "subquery";
-	query;
-	constructor(query) {
-		super();
-		this.query = query;
-		this.freeze();
-	}
-	static of(query) {
-		return new SubqueryExpr(query);
-	}
-	accept(visitor) {
-		return visitor.subquery(this);
-	}
-	rewrite(rewriter) {
-		return new SubqueryExpr(this.query.rewrite(rewriter));
-	}
-	fold(folder) {
-		return folder.select ? folder.select(this.query) : folder.empty;
-	}
-};
-var OperationExpr = class OperationExpr extends Expression {
-	kind = "operation";
-	method;
-	self;
-	args;
-	returns;
-	lowering;
-	constructor(options) {
-		super();
-		this.method = options.method;
-		this.self = options.self;
-		this.args = frozenArrayCopy(options.args ?? []);
-		this.returns = options.returns;
-		this.lowering = options.lowering;
-		this.freeze();
-	}
-	accept(visitor) {
-		return visitor.operation(this);
-	}
-	rewrite(rewriter) {
-		return new OperationExpr({
-			method: this.method,
-			self: this.self.rewrite(rewriter),
-			args: this.args.map((arg) => rewriteComparable(arg, rewriter)),
-			returns: this.returns,
-			lowering: this.lowering
-		});
-	}
-	fold(folder) {
-		return combineAll(folder, [() => this.self.fold(folder), ...this.args.map((arg) => () => foldComparable(arg, folder))]);
-	}
-	baseColumnRef() {
-		return this.self.baseColumnRef();
-	}
-};
-var AggregateExpr = class AggregateExpr extends Expression {
-	kind = "aggregate";
-	fn;
-	expr;
-	constructor(fn, expr) {
-		super();
-		if (fn !== "count" && expr === void 0) throw new Error(`Aggregate function "${fn}" requires an expression`);
-		this.fn = fn;
-		this.expr = expr;
-		this.freeze();
-	}
-	static count(expr) {
-		return new AggregateExpr("count", expr);
-	}
-	static sum(expr) {
-		return new AggregateExpr("sum", expr);
-	}
-	static avg(expr) {
-		return new AggregateExpr("avg", expr);
-	}
-	static min(expr) {
-		return new AggregateExpr("min", expr);
-	}
-	static max(expr) {
-		return new AggregateExpr("max", expr);
-	}
-	accept(visitor) {
-		return visitor.aggregate(this);
-	}
-	rewrite(rewriter) {
-		return this.expr === void 0 ? this : new AggregateExpr(this.fn, this.expr.rewrite(rewriter));
-	}
-	fold(folder) {
-		return this.expr ? this.expr.fold(folder) : folder.empty;
-	}
-};
-var JsonObjectExpr = class JsonObjectExpr extends Expression {
-	kind = "json-object";
-	entries;
-	constructor(entries) {
-		super();
-		this.entries = frozenArrayCopy(entries.map((entry) => Object.freeze({ ...entry })));
-		this.freeze();
-	}
-	static entry(key, value) {
-		return {
-			key,
-			value
-		};
-	}
-	static fromEntries(entries) {
-		return new JsonObjectExpr(entries);
-	}
-	accept(visitor) {
-		return visitor.jsonObject(this);
-	}
-	rewrite(rewriter) {
-		return new JsonObjectExpr(this.entries.map((entry) => ({
-			key: entry.key,
-			value: entry.value.kind === "literal" ? rewriter.literal ? rewriter.literal(entry.value) : entry.value : entry.value.rewrite(rewriter)
-		})));
-	}
-	fold(folder) {
-		return combineAll(folder, this.entries.map((entry) => () => entry.value.kind === "literal" ? folder.literal ? folder.literal(entry.value) : folder.empty : entry.value.fold(folder)));
-	}
-};
-var OrderByItem = class OrderByItem extends AstNode {
-	kind = "order-by-item";
-	expr;
-	dir;
-	constructor(expr, dir) {
-		super();
-		this.expr = expr;
-		this.dir = dir;
-		this.freeze();
-	}
-	static asc(expr) {
-		return new OrderByItem(expr, "asc");
-	}
-	static desc(expr) {
-		return new OrderByItem(expr, "desc");
-	}
-	rewrite(rewriter) {
-		return new OrderByItem(this.expr.rewrite(rewriter), this.dir);
-	}
-};
-var JsonArrayAggExpr = class JsonArrayAggExpr extends Expression {
-	kind = "json-array-agg";
-	expr;
-	onEmpty;
-	orderBy;
-	constructor(expr, onEmpty = "null", orderBy) {
-		super();
-		this.expr = expr;
-		this.onEmpty = onEmpty;
-		this.orderBy = orderBy && orderBy.length > 0 ? frozenArrayCopy(orderBy) : void 0;
-		this.freeze();
-	}
-	static of(expr, onEmpty = "null", orderBy) {
-		return new JsonArrayAggExpr(expr, onEmpty, orderBy);
-	}
-	accept(visitor) {
-		return visitor.jsonArrayAgg(this);
-	}
-	rewrite(rewriter) {
-		return new JsonArrayAggExpr(this.expr.rewrite(rewriter), this.onEmpty, this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)));
-	}
-	fold(folder) {
-		return combineAll(folder, [() => this.expr.fold(folder), ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder))]);
-	}
-};
-var ListExpression = class ListExpression extends Expression {
-	kind = "list";
-	values;
-	constructor(values) {
-		super();
-		this.values = frozenArrayCopy(values);
-		this.freeze();
-	}
-	static of(values) {
-		return new ListExpression(values);
-	}
-	static fromValues(values) {
-		return new ListExpression(values.map((value) => new LiteralExpr(value)));
-	}
-	accept(visitor) {
-		return visitor.list(this);
-	}
-	rewrite(rewriter) {
-		if (rewriter.list) return rewriter.list(this);
-		return new ListExpression(this.values.map((value) => value.rewrite(rewriter)));
-	}
-	fold(folder) {
-		if (folder.list) return folder.list(this);
-		return combineAll(folder, this.values.map((value) => () => value.fold(folder)));
-	}
-};
-var BinaryExpr = class BinaryExpr extends Expression {
-	kind = "binary";
-	op;
-	left;
-	right;
-	constructor(op, left, right) {
-		super();
-		this.op = op;
-		this.left = left;
-		this.right = right;
-		this.freeze();
-	}
-	static eq(left, right) {
-		return new BinaryExpr("eq", left, right);
-	}
-	static neq(left, right) {
-		return new BinaryExpr("neq", left, right);
-	}
-	static gt(left, right) {
-		return new BinaryExpr("gt", left, right);
-	}
-	static lt(left, right) {
-		return new BinaryExpr("lt", left, right);
-	}
-	static gte(left, right) {
-		return new BinaryExpr("gte", left, right);
-	}
-	static lte(left, right) {
-		return new BinaryExpr("lte", left, right);
-	}
-	static like(left, right) {
-		return new BinaryExpr("like", left, right);
-	}
-	static in(left, right) {
-		return new BinaryExpr("in", left, right);
-	}
-	static notIn(left, right) {
-		return new BinaryExpr("notIn", left, right);
-	}
-	accept(visitor) {
-		return visitor.binary(this);
-	}
-	rewrite(rewriter) {
-		return new BinaryExpr(this.op, rewriteComparable(this.left, rewriter), rewriteComparable(this.right, rewriter));
-	}
-	fold(folder) {
-		return combineAll(folder, [() => foldComparable(this.left, folder), () => foldComparable(this.right, folder)]);
-	}
-};
-var AndExpr = class AndExpr extends Expression {
-	kind = "and";
-	exprs;
-	constructor(exprs) {
-		super();
-		this.exprs = frozenArrayCopy(exprs);
-		this.freeze();
-	}
-	static of(exprs) {
-		return new AndExpr(exprs);
-	}
-	static true() {
-		return new AndExpr([]);
-	}
-	accept(visitor) {
-		return visitor.and(this);
-	}
-	rewrite(rewriter) {
-		return new AndExpr(this.exprs.map((expr) => expr.rewrite(rewriter)));
-	}
-	fold(folder) {
-		return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder)));
-	}
-};
-var OrExpr = class OrExpr extends Expression {
-	kind = "or";
-	exprs;
-	constructor(exprs) {
-		super();
-		this.exprs = frozenArrayCopy(exprs);
-		this.freeze();
-	}
-	static of(exprs) {
-		return new OrExpr(exprs);
-	}
-	static false() {
-		return new OrExpr([]);
-	}
-	accept(visitor) {
-		return visitor.or(this);
-	}
-	rewrite(rewriter) {
-		return new OrExpr(this.exprs.map((expr) => expr.rewrite(rewriter)));
-	}
-	fold(folder) {
-		return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder)));
-	}
-};
-var ExistsExpr = class ExistsExpr extends Expression {
-	kind = "exists";
-	notExists;
-	subquery;
-	constructor(subquery, notExists = false) {
-		super();
-		this.notExists = notExists;
-		this.subquery = subquery;
-		this.freeze();
-	}
-	static exists(subquery) {
-		return new ExistsExpr(subquery, false);
-	}
-	static notExists(subquery) {
-		return new ExistsExpr(subquery, true);
-	}
-	accept(visitor) {
-		return visitor.exists(this);
-	}
-	rewrite(rewriter) {
-		return new ExistsExpr(this.subquery.rewrite(rewriter), this.notExists);
-	}
-	fold(folder) {
-		return folder.select ? folder.select(this.subquery) : folder.empty;
-	}
-};
-var NullCheckExpr = class NullCheckExpr extends Expression {
-	kind = "null-check";
-	expr;
-	isNull;
-	constructor(expr, isNull) {
-		super();
-		this.expr = expr;
-		this.isNull = isNull;
-		this.freeze();
-	}
-	static isNull(expr) {
-		return new NullCheckExpr(expr, true);
-	}
-	static isNotNull(expr) {
-		return new NullCheckExpr(expr, false);
-	}
-	accept(visitor) {
-		return visitor.nullCheck(this);
-	}
-	rewrite(rewriter) {
-		return new NullCheckExpr(this.expr.rewrite(rewriter), this.isNull);
-	}
-	fold(folder) {
-		return this.expr.fold(folder);
-	}
-};
-var NotExpr = class NotExpr extends Expression {
-	kind = "not";
-	expr;
-	constructor(expr) {
-		super();
-		this.expr = expr;
-		this.freeze();
-	}
-	toWhereExpr() {
-		return this;
-	}
-	accept(visitor) {
-		return visitor.not(this);
-	}
-	rewrite(rewriter) {
-		return new NotExpr(this.expr.rewrite(rewriter));
-	}
-	fold(folder) {
-		return this.expr.fold(folder);
-	}
-};
-var EqColJoinOn = class EqColJoinOn extends AstNode {
-	kind = "eq-col-join-on";
-	left;
-	right;
-	constructor(left, right) {
-		super();
-		this.left = left;
-		this.right = right;
-		this.freeze();
-	}
-	static of(left, right) {
-		return new EqColJoinOn(left, right);
-	}
-	rewrite(rewriter) {
-		return rewriter.eqColJoinOn ? rewriter.eqColJoinOn(this) : this;
-	}
-};
-var JoinAst = class JoinAst extends AstNode {
-	kind = "join";
-	joinType;
-	source;
-	lateral;
-	on;
-	constructor(joinType, source, on, lateral = false) {
-		super();
-		this.joinType = joinType;
-		this.source = source;
-		this.lateral = lateral;
-		this.on = on;
-		this.freeze();
-	}
-	static inner(source, on, lateral = false) {
-		return new JoinAst("inner", source, on, lateral);
-	}
-	static left(source, on, lateral = false) {
-		return new JoinAst("left", source, on, lateral);
-	}
-	static right(source, on, lateral = false) {
-		return new JoinAst("right", source, on, lateral);
-	}
-	static full(source, on, lateral = false) {
-		return new JoinAst("full", source, on, lateral);
-	}
-	rewrite(rewriter) {
-		return new JoinAst(this.joinType, this.source.rewrite(rewriter), this.on.kind === "eq-col-join-on" ? this.on.rewrite(rewriter) : this.on.rewrite(rewriter), this.lateral);
-	}
-};
-var ProjectionItem = class ProjectionItem extends AstNode {
-	kind = "projection-item";
-	alias;
-	expr;
-	constructor(alias, expr) {
-		super();
-		this.alias = alias;
-		this.expr = expr;
-		this.freeze();
-	}
-	static of(alias, expr) {
-		return new ProjectionItem(alias, expr);
-	}
-};
-var SelectAst = class SelectAst extends QueryAst {
-	kind = "select";
-	from;
-	joins;
-	projection;
-	where;
-	orderBy;
-	distinct;
-	distinctOn;
-	groupBy;
-	having;
-	limit;
-	offset;
-	selectAllIntent;
-	constructor(options) {
-		super();
-		this.from = options.from;
-		this.joins = options.joins && options.joins.length > 0 ? frozenArrayCopy(options.joins) : void 0;
-		this.projection = frozenArrayCopy(options.projection);
-		this.where = options.where;
-		this.orderBy = options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : void 0;
-		this.distinct = options.distinct;
-		this.distinctOn = options.distinctOn && options.distinctOn.length > 0 ? frozenArrayCopy(options.distinctOn) : void 0;
-		this.groupBy = options.groupBy && options.groupBy.length > 0 ? frozenArrayCopy(options.groupBy) : void 0;
-		this.having = options.having;
-		this.limit = options.limit;
-		this.offset = options.offset;
-		this.selectAllIntent = frozenOptionalRecordCopy(options.selectAllIntent);
-		this.freeze();
-	}
-	static from(from) {
-		return new SelectAst({
-			from,
-			joins: void 0,
-			projection: [],
-			where: void 0,
-			orderBy: void 0,
-			distinct: void 0,
-			distinctOn: void 0,
-			groupBy: void 0,
-			having: void 0,
-			limit: void 0,
-			offset: void 0,
-			selectAllIntent: void 0
-		});
-	}
-	withFrom(from) {
-		return new SelectAst({
-			...this,
-			from
-		});
-	}
-	withJoins(joins) {
-		return new SelectAst({
-			...this,
-			joins: joins.length > 0 ? joins : void 0
-		});
-	}
-	withProjection(projection) {
-		return new SelectAst({
-			...this,
-			projection
-		});
-	}
-	addProjection(alias, expr) {
-		return new SelectAst({
-			...this,
-			projection: [...this.projection, new ProjectionItem(alias, expr)]
-		});
-	}
-	withWhere(where) {
-		return new SelectAst({
-			...this,
-			where
-		});
-	}
-	withOrderBy(orderBy) {
-		return new SelectAst({
-			...this,
-			orderBy: orderBy.length > 0 ? orderBy : void 0
-		});
-	}
-	withDistinct(enabled = true) {
-		return new SelectAst({
-			...this,
-			distinct: enabled ? true : void 0
-		});
-	}
-	withDistinctOn(distinctOn) {
-		return new SelectAst({
-			...this,
-			distinctOn: distinctOn.length > 0 ? distinctOn : void 0
-		});
-	}
-	withGroupBy(groupBy) {
-		return new SelectAst({
-			...this,
-			groupBy: groupBy.length > 0 ? groupBy : void 0
-		});
-	}
-	withHaving(having) {
-		return new SelectAst({
-			...this,
-			having
-		});
-	}
-	withLimit(limit) {
-		return new SelectAst({
-			...this,
-			limit
-		});
-	}
-	withOffset(offset) {
-		return new SelectAst({
-			...this,
-			offset
-		});
-	}
-	withSelectAllIntent(selectAllIntent) {
-		return new SelectAst({
-			...this,
-			selectAllIntent
-		});
-	}
-	rewrite(rewriter) {
-		const rewritten = new SelectAst({
-			from: this.from.rewrite(rewriter),
-			joins: this.joins?.map((join) => join.rewrite(rewriter)),
-			projection: this.projection.map((projection) => new ProjectionItem(projection.alias, projection.expr.kind === "literal" ? rewriter.literal ? rewriter.literal(projection.expr) : projection.expr : projection.expr.rewrite(rewriter))),
-			where: this.where?.rewrite(rewriter),
-			orderBy: this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)),
-			distinct: this.distinct,
-			distinctOn: this.distinctOn?.map((expr) => expr.rewrite(rewriter)),
-			groupBy: this.groupBy?.map((expr) => expr.rewrite(rewriter)),
-			having: this.having?.rewrite(rewriter),
-			limit: this.limit,
-			offset: this.offset,
-			selectAllIntent: this.selectAllIntent
-		});
-		return rewriter.select ? rewriter.select(rewritten) : rewritten;
-	}
-	collectColumnRefs() {
-		const refs = [];
-		const pushRefs = (columns) => {
-			refs.push(...columns);
-		};
-		if (this.from.kind === "derived-table-source") pushRefs(this.from.query.collectColumnRefs());
-		for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectColumnRefs());
-		if (this.where) pushRefs(this.where.collectColumnRefs());
-		if (this.having) pushRefs(this.having.collectColumnRefs());
-		for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectColumnRefs());
-		for (const expr of this.distinctOn ?? []) pushRefs(expr.collectColumnRefs());
-		for (const expr of this.groupBy ?? []) pushRefs(expr.collectColumnRefs());
-		for (const join of this.joins ?? []) {
-			if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectColumnRefs());
-			if (join.on.kind === "eq-col-join-on") refs.push(join.on.left, join.on.right);
-			else pushRefs(join.on.collectColumnRefs());
-		}
-		return refs;
-	}
-	collectParamRefs() {
-		const refs = [];
-		const pushRefs = (params) => {
-			refs.push(...params);
-		};
-		if (this.from.kind === "derived-table-source") pushRefs(this.from.query.collectParamRefs());
-		for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectParamRefs());
-		if (this.where) pushRefs(this.where.collectParamRefs());
-		if (this.having) pushRefs(this.having.collectParamRefs());
-		for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectParamRefs());
-		for (const expr of this.distinctOn ?? []) pushRefs(expr.collectParamRefs());
-		for (const expr of this.groupBy ?? []) pushRefs(expr.collectParamRefs());
-		for (const join of this.joins ?? []) {
-			if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectParamRefs());
-			if (!(join.on.kind === "eq-col-join-on")) pushRefs(join.on.collectParamRefs());
-		}
-		return refs;
-	}
-	collectRefs() {
-		const tables = /* @__PURE__ */ new Set();
-		const columns = /* @__PURE__ */ new Map();
-		const addSource = (source) => {
-			mergeRefsInto(source.collectRefs(), tables, columns);
-		};
-		addSource(this.from);
-		for (const join of this.joins ?? []) {
-			addSource(join.source);
-			if (join.on.kind === "eq-col-join-on") {
-				addColumnRefToRefSets(join.on.left, tables, columns);
-				addColumnRefToRefSets(join.on.right, tables, columns);
-			} else for (const columnRef of join.on.collectColumnRefs()) addColumnRefToRefSets(columnRef, tables, columns);
-		}
-		for (const columnRef of this.collectColumnRefs()) addColumnRefToRefSets(columnRef, tables, columns);
-		return sortRefs(tables, columns);
-	}
-	toQueryAst() {
-		return this;
-	}
-};
-var InsertOnConflictAction = class extends AstNode {};
-var DoNothingConflictAction = class extends InsertOnConflictAction {
-	kind = "do-nothing";
-	constructor() {
-		super();
-		this.freeze();
-	}
-	toInsertOnConflictAction() {
-		return this;
-	}
-};
-var DoUpdateSetConflictAction = class extends InsertOnConflictAction {
-	kind = "do-update-set";
-	set;
-	constructor(set) {
-		super();
-		this.set = frozenRecordCopy(set);
-		this.freeze();
-	}
-	toInsertOnConflictAction() {
-		return this;
-	}
-};
-var InsertOnConflict = class InsertOnConflict extends AstNode {
-	kind = "insert-on-conflict";
-	columns;
-	action;
-	constructor(columns, action) {
-		super();
-		this.columns = frozenArrayCopy(columns);
-		this.action = action;
-		this.freeze();
-	}
-	static on(columns) {
-		return new InsertOnConflict(columns, new DoNothingConflictAction());
-	}
-	doNothing() {
-		return new InsertOnConflict(this.columns, new DoNothingConflictAction());
-	}
-	doUpdateSet(set) {
-		return new InsertOnConflict(this.columns, new DoUpdateSetConflictAction(set));
-	}
-};
-var InsertAst = class InsertAst extends QueryAst {
-	kind = "insert";
-	table;
-	rows;
-	onConflict;
-	returning;
-	constructor(table, rows = [{}], onConflict, returning) {
-		super();
-		this.table = table;
-		this.rows = freezeRows(rows);
-		this.onConflict = onConflict;
-		this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0;
-		this.freeze();
-	}
-	static into(table) {
-		return new InsertAst(table);
-	}
-	withValues(values) {
-		return new InsertAst(this.table, [{ ...values }], this.onConflict, this.returning);
-	}
-	withRows(rows) {
-		return new InsertAst(this.table, rows.map((row) => ({ ...row })), this.onConflict, this.returning);
-	}
-	withReturning(returning) {
-		return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), this.onConflict, returning);
-	}
-	withOnConflict(onConflict) {
-		return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), onConflict, this.returning);
-	}
-	collectParamRefs() {
-		const refs = [];
-		for (const row of this.rows) for (const value of Object.values(row)) if (value.kind === "param-ref") refs.push(value);
-		if (this.onConflict?.action.kind === "do-update-set") {
-			for (const value of Object.values(this.onConflict.action.set)) if (value.kind === "param-ref") refs.push(value);
-		}
-		return refs;
-	}
-	collectRefs() {
-		const tables = new Set([this.table.name]);
-		const columns = /* @__PURE__ */ new Map();
-		const addColumn = (columnRef) => addColumnRefToRefSets(columnRef, tables, columns);
-		const addValue = (value) => {
-			if (value.kind === "column-ref") addColumn(value);
-		};
-		for (const row of this.rows) for (const value of Object.values(row)) addValue(value);
-		for (const columnRef of this.returning ?? []) addColumn(columnRef);
-		if (this.onConflict) {
-			for (const columnRef of this.onConflict.columns) addColumn(columnRef);
-			if (this.onConflict.action.kind === "do-update-set") {
-				for (const value of Object.values(this.onConflict.action.set)) if (value.kind === "column-ref") addColumn(value);
-			}
-		}
-		return sortRefs(tables, columns);
-	}
-	toQueryAst() {
-		return this;
-	}
-};
-var UpdateAst = class UpdateAst extends QueryAst {
-	kind = "update";
-	table;
-	set;
-	where;
-	returning;
-	constructor(table, set = {}, where, returning) {
-		super();
-		this.table = table;
-		this.set = frozenRecordCopy(set);
-		this.where = where;
-		this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0;
-		this.freeze();
-	}
-	static table(table) {
-		return new UpdateAst(table);
-	}
-	withSet(set) {
-		return new UpdateAst(this.table, set, this.where, this.returning);
-	}
-	withWhere(where) {
-		return new UpdateAst(this.table, this.set, where, this.returning);
-	}
-	withReturning(returning) {
-		return new UpdateAst(this.table, this.set, this.where, returning);
-	}
-	collectParamRefs() {
-		const refs = [];
-		for (const value of Object.values(this.set)) if (value.kind === "param-ref") refs.push(value);
-		if (this.where) refs.push(...this.where.collectParamRefs());
-		return refs;
-	}
-	collectRefs() {
-		const tables = new Set([this.table.name]);
-		const columns = /* @__PURE__ */ new Map();
-		for (const value of Object.values(this.set)) if (value.kind === "column-ref") addColumnRefToRefSets(value, tables, columns);
-		for (const columnRef of this.where?.collectColumnRefs() ?? []) addColumnRefToRefSets(columnRef, tables, columns);
-		for (const columnRef of this.returning ?? []) addColumnRefToRefSets(columnRef, tables, columns);
-		return sortRefs(tables, columns);
-	}
-	toQueryAst() {
-		return this;
-	}
-};
-var DeleteAst = class DeleteAst extends QueryAst {
-	kind = "delete";
-	table;
-	where;
-	returning;
-	constructor(table, where, returning) {
-		super();
-		this.table = table;
-		this.where = where;
-		this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0;
-		this.freeze();
-	}
-	static from(table) {
-		return new DeleteAst(table);
-	}
-	withWhere(where) {
-		return new DeleteAst(this.table, where, this.returning);
-	}
-	withReturning(returning) {
-		return new DeleteAst(this.table, this.where, returning);
-	}
-	collectParamRefs() {
-		return this.where?.collectParamRefs() ?? [];
-	}
-	collectRefs() {
-		const tables = new Set([this.table.name]);
-		const columns = /* @__PURE__ */ new Map();
-		for (const columnRef of this.where?.collectColumnRefs() ?? []) addColumnRefToRefSets(columnRef, tables, columns);
-		for (const columnRef of this.returning ?? []) addColumnRefToRefSets(columnRef, tables, columns);
-		return sortRefs(tables, columns);
-	}
-	toQueryAst() {
-		return this;
-	}
-};
-const queryAstKinds = new Set([
-	"select",
-	"insert",
-	"update",
-	"delete"
-]);
-const whereExprKinds = new Set([
-	"binary",
-	"and",
-	"or",
-	"exists",
-	"null-check",
-	"not"
-]);
-function isQueryAst(value) {
-	return typeof value === "object" && value !== null && "kind" in value && queryAstKinds.has(value.kind);
-}
-function isWhereExpr(value) {
-	return typeof value === "object" && value !== null && "kind" in value && whereExprKinds.has(value.kind);
-}
-
 //#endregion
 //#region src/ast/util.ts
 function compact(o) {
@@ -1349,7 +303,27 @@ function compact(o) {
 	}
 	return out;
 }
+/**
+* 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.
+*/
+function collectOrderedParamRefs(ast) {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const ref of ast.collectParamRefs()) {
+		if (seen.has(ref)) continue;
+		seen.add(ref);
+		ordered.push(ref);
+	}
+	return Object.freeze(ordered);
+}
 
 //#endregion
-export { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, 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, SubqueryExpr, TableSource, UpdateAst, codec, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
+export { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, 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, SubqueryExpr, TableSource, UpdateAst, codec, collectOrderedParamRefs, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
 //# sourceMappingURL=ast.mjs.map