@prisma-next/sql-relational-core 0.5.0-dev.6 → 0.5.0-dev.61

package/dist/exports/ast.mjs

@@ -1,1342 +1,236 @@
-import { ifDefined } from "@prisma-next/utils/defined";
+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-CO7zrXfK.mjs";
+import { CodecDescriptorImpl, CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec";
 import { type } from "arktype";
+import { runtimeError } from "@prisma-next/framework-components/runtime";
 
-//#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]);
-		}
-	}
-	hasTrait(codecId, trait) {
-		return this._byId.get(codecId)?.traits?.includes(trait) ?? false;
-	}
-	traitsOf(codecId) {
-		return this._byId.get(codecId)?.traits ?? [];
-	}
-	/**
-	* 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.
-* Provides identity defaults for encodeJson/decodeJson when not supplied.
-*/
-function codec(config) {
-	const identity = (v) => v;
-	return {
-		id: config.typeId,
-		targetTypes: config.targetTypes,
-		...ifDefined("meta", config.meta),
-		...ifDefined("paramsSchema", config.paramsSchema),
-		...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
-	};
-}
-/**
-* Implementation of CodecDefBuilder.
-*/
-var CodecDefBuilderImpl = class CodecDefBuilderImpl {
-	_codecs;
-	CodecTypes;
-	dataTypes;
-	constructor(codecs$1) {
-		this._codecs = codecs$1;
-		const codecTypes = {};
-		for (const [, codecImpl] of Object.entries(this._codecs)) {
-			const codecImplTyped = codecImpl;
-			codecTypes[codecImplTyped.id] = {
-				input: void 0,
-				output: void 0,
-				traits: 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/sql-codecs.ts
+//#region src/ast/sql-codec-helpers.ts
 const SQL_CHAR_CODEC_ID = "sql/char@1";
 const SQL_VARCHAR_CODEC_ID = "sql/varchar@1";
 const SQL_INT_CODEC_ID = "sql/int@1";
 const SQL_FLOAT_CODEC_ID = "sql/float@1";
 const SQL_TEXT_CODEC_ID = "sql/text@1";
 const SQL_TIMESTAMP_CODEC_ID = "sql/timestamp@1";
-const lengthParamsSchema = type({ length: "number.integer > 0" });
-const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
-function createLengthTypeHelper(kind) {
-	return (params) => ({
-		kind,
-		maxLength: params["length"]
-	});
-}
-const sqlCharCodec = codec({
-	typeId: SQL_CHAR_CODEC_ID,
-	targetTypes: ["char"],
-	traits: [
-		"equality",
-		"order",
-		"textual"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire.trimEnd(),
-	paramsSchema: lengthParamsSchema,
-	init: createLengthTypeHelper("fixed"),
-	renderOutputType: (typeParams) => {
-		const length = typeParams["length"];
-		if (length === void 0) return void 0;
-		if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for Char, got ${String(length)}`);
-		return `Char<${length}>`;
-	}
-});
-const sqlVarcharCodec = codec({
-	typeId: SQL_VARCHAR_CODEC_ID,
-	targetTypes: ["varchar"],
-	traits: [
-		"equality",
-		"order",
-		"textual"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire,
-	paramsSchema: lengthParamsSchema,
-	init: createLengthTypeHelper("variable"),
-	renderOutputType: (typeParams) => {
-		const length = typeParams["length"];
-		if (length === void 0) return void 0;
-		if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for Varchar, got ${String(length)}`);
-		return `Varchar<${length}>`;
-	}
-});
-const sqlIntCodec = codec({
-	typeId: SQL_INT_CODEC_ID,
-	targetTypes: ["int"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire
-});
-const sqlFloatCodec = codec({
-	typeId: SQL_FLOAT_CODEC_ID,
-	targetTypes: ["float"],
-	traits: [
-		"equality",
-		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire
-});
-const sqlTextCodec = codec({
-	typeId: SQL_TEXT_CODEC_ID,
-	targetTypes: ["text"],
-	traits: [
-		"equality",
-		"order",
-		"textual"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire
-});
-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,
-	paramsSchema: precisionParamsSchema,
-	renderOutputType: (typeParams) => {
-		const precision = typeParams["precision"];
-		if (precision === void 0) return "Timestamp";
-		if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for Timestamp, got ${String(precision)}`);
-		return `Timestamp<${precision}>`;
-	}
-});
-const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec).add("text", sqlTextCodec).add("timestamp", sqlTimestampCodec);
-const sqlCodecDefinitions = codecs.codecDefinitions;
-const sqlDataTypes = codecs.dataTypes;
+const sqlCharEncode = (value) => value;
+const sqlCharDecode = (wire) => wire.trimEnd();
+const sqlCharRenderOutputType = (typeParams) => {
+	const length = typeParams.length;
+	if (length === void 0) return void 0;
+	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for Char, got ${String(length)}`);
+	return `Char<${length}>`;
+};
+const sqlVarcharEncode = (value) => value;
+const sqlVarcharDecode = (wire) => wire;
+const sqlVarcharRenderOutputType = (typeParams) => {
+	const length = typeParams.length;
+	if (length === void 0) return void 0;
+	if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for Varchar, got ${String(length)}`);
+	return `Varchar<${length}>`;
+};
+const sqlIntEncode = (value) => value;
+const sqlIntDecode = (wire) => wire;
+const sqlFloatEncode = (value) => value;
+const sqlFloatDecode = (wire) => wire;
+const sqlTextEncode = (value) => value;
+const sqlTextDecode = (wire) => wire;
+const sqlTimestampEncode = (value) => value;
+const sqlTimestampDecode = (wire) => wire;
+const sqlTimestampEncodeJson = (value) => value.toISOString();
+const sqlTimestampDecodeJson = (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;
+};
+const sqlTimestampRenderOutputType = (typeParams) => {
+	const precision = typeParams.precision;
+	if (precision === void 0) return "Timestamp";
+	if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for Timestamp, got ${String(precision)}`);
+	return `Timestamp<${precision}>`;
+};
 
 //#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);
+//#region src/ast/sql-codecs.ts
+const lengthParamsSchema = type({ "length?": "number.integer > 0" });
+const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
+var SqlTextCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlTextEncode(value);
 	}
-	accept(visitor) {
-		return visitor.exists(this);
+	async decode(wire, _ctx) {
+		return sqlTextDecode(wire);
 	}
-	rewrite(rewriter) {
-		return new ExistsExpr(this.subquery.rewrite(rewriter), this.notExists);
+	encodeJson(value) {
+		return value;
 	}
-	fold(folder) {
-		return folder.select ? folder.select(this.subquery) : folder.empty;
+	decodeJson(json) {
+		return json;
 	}
 };
-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 SqlTextDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_TEXT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	targetTypes = ["text"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new SqlTextCodec(this);
 	}
 };
-var NotExpr = class NotExpr extends Expression {
-	kind = "not";
-	expr;
-	constructor(expr) {
-		super();
-		this.expr = expr;
-		this.freeze();
-	}
-	toWhereExpr() {
-		return this;
+const sqlTextDescriptor = new SqlTextDescriptor();
+const sqlTextColumn = () => column(sqlTextDescriptor.factory(), sqlTextDescriptor.codecId, void 0, "text");
+var SqlIntCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlIntEncode(value);
 	}
-	accept(visitor) {
-		return visitor.not(this);
+	async decode(wire, _ctx) {
+		return sqlIntDecode(wire);
 	}
-	rewrite(rewriter) {
-		return new NotExpr(this.expr.rewrite(rewriter));
+	encodeJson(value) {
+		return value;
 	}
-	fold(folder) {
-		return this.expr.fold(folder);
+	decodeJson(json) {
+		return json;
 	}
 };
-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 SqlIntDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_INT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["int"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new SqlIntCodec(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);
+const sqlIntDescriptor = new SqlIntDescriptor();
+const sqlIntColumn = () => column(sqlIntDescriptor.factory(), sqlIntDescriptor.codecId, void 0, "int");
+var SqlFloatCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlFloatEncode(value);
 	}
-	static right(source, on, lateral = false) {
-		return new JoinAst("right", source, on, lateral);
+	async decode(wire, _ctx) {
+		return sqlFloatDecode(wire);
 	}
-	static full(source, on, lateral = false) {
-		return new JoinAst("full", source, on, lateral);
+	encodeJson(value) {
+		return value;
 	}
-	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);
+	decodeJson(json) {
+		return json;
 	}
 };
-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 SqlFloatDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_FLOAT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = ["float"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new SqlFloatCodec(this);
 	}
 };
-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
-		});
+const sqlFloatDescriptor = new SqlFloatDescriptor();
+const sqlFloatColumn = () => column(sqlFloatDescriptor.factory(), sqlFloatDescriptor.codecId, void 0, "float");
+var SqlCharCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlCharEncode(value);
 	}
-	addProjection(alias, expr) {
-		return new SelectAst({
-			...this,
-			projection: [...this.projection, new ProjectionItem(alias, expr)]
-		});
+	async decode(wire, _ctx) {
+		return sqlCharDecode(wire);
 	}
-	withWhere(where) {
-		return new SelectAst({
-			...this,
-			where
-		});
+	encodeJson(value) {
+		return value;
 	}
-	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;
+	decodeJson(json) {
+		return json;
 	}
 };
-var DoUpdateSetConflictAction = class extends InsertOnConflictAction {
-	kind = "do-update-set";
-	set;
-	constructor(set) {
-		super();
-		this.set = frozenRecordCopy(set);
-		this.freeze();
+var SqlCharDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_CHAR_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	targetTypes = ["char"];
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return sqlCharRenderOutputType(params);
 	}
-	toInsertOnConflictAction() {
-		return this;
+	factory(_params) {
+		return () => new SqlCharCodec(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();
+const sqlCharDescriptor = new SqlCharDescriptor();
+const sqlCharColumn = (params = {}) => column(sqlCharDescriptor.factory(params), sqlCharDescriptor.codecId, params, "char");
+var SqlVarcharCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlVarcharEncode(value);
 	}
-	static on(columns) {
-		return new InsertOnConflict(columns, new DoNothingConflictAction());
+	async decode(wire, _ctx) {
+		return sqlVarcharDecode(wire);
 	}
-	doNothing() {
-		return new InsertOnConflict(this.columns, new DoNothingConflictAction());
+	encodeJson(value) {
+		return value;
 	}
-	doUpdateSet(set) {
-		return new InsertOnConflict(this.columns, new DoUpdateSetConflictAction(set));
+	decodeJson(json) {
+		return json;
 	}
 };
-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);
+var SqlVarcharDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_VARCHAR_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"textual"
+	];
+	targetTypes = ["varchar"];
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return sqlVarcharRenderOutputType(params);
 	}
-	toQueryAst() {
-		return this;
+	factory(_params) {
+		return () => new SqlVarcharCodec(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);
+const sqlVarcharDescriptor = new SqlVarcharDescriptor();
+const sqlVarcharColumn = (params = {}) => column(sqlVarcharDescriptor.factory(params), sqlVarcharDescriptor.codecId, params, "varchar");
+var SqlTimestampCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlTimestampEncode(value);
 	}
-	withWhere(where) {
-		return new UpdateAst(this.table, this.set, where, this.returning);
+	async decode(wire, _ctx) {
+		return sqlTimestampDecode(wire);
 	}
-	withReturning(returning) {
-		return new UpdateAst(this.table, this.set, this.where, returning);
+	encodeJson(value) {
+		return sqlTimestampEncodeJson(value);
 	}
-	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;
+	decodeJson(json) {
+		return sqlTimestampDecodeJson(json);
 	}
 };
-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);
+var SqlTimestampDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_TIMESTAMP_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamp"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return sqlTimestampRenderOutputType(params);
 	}
-	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;
+	factory(_params) {
+		return () => new SqlTimestampCodec(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);
-}
+const sqlTimestampDescriptor = new SqlTimestampDescriptor();
+const sqlTimestampColumn = (params = {}) => column(sqlTimestampDescriptor.factory(params), sqlTimestampDescriptor.codecId, params, "timestamp");
 
 //#endregion
 //#region src/ast/util.ts
@@ -1349,7 +243,57 @@ 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
+//#region src/ast/validate-param-refs.ts
+/**
+* Builder-pipeline validator pass: every {@link ParamRef} whose `codecId` resolves to a *parameterized* descriptor must carry `refs: { table, column }` so encode-side dispatch can call `contractCodecs.forColumn(table, column)`. Refs-less parameterized `ParamRef`s are a hard error — the codec-id-keyed `forCodecId` fallback cannot disambiguate per-instance codecs (e.g. `vector(1024)` vs. `vector(1536)`), so the dispatch
+* path must reject them at validation time rather than silently bind to the wrong instance.
+*
+* Non-parameterized codec ids (the `voidParamsSchema` case) are always dispatch-safe via codec id alone, so refs-less ParamRefs for those ids are accepted unchanged.
+*
+* The pass runs post-build / pre-execute — the natural location is the SQL runtime's `lower()` step, between any `beforeCompile` rewrites and `encodeParams`. See AC-5 in the codec-registry-unification spec.
+*/
+/**
+* Validate that every parameterized-codec `ParamRef` in `plan` carries `refs`. Throws `RUNTIME.PARAM_REF_REFS_REQUIRED` (a runtime envelope) naming the codec id and the binding label when the invariant is violated. Returns the plan unchanged on success — callers that prefer a side-effecting assertion can ignore the return value.
+*
+* The `registry` is consulted via `descriptorFor(codecId).isParameterized` — `true` whenever the descriptor's `paramsSchema` is not the singleton `voidParamsSchema`.
+*/
+function validateParamRefRefs(plan, registry) {
+	for (const ref of collectOrderedParamRefs(plan)) diagnoseRef(ref, registry);
+}
+function diagnoseRef(ref, registry) {
+	if (!ref.codecId) return;
+	const descriptor = registry.descriptorFor(ref.codecId);
+	if (descriptor === void 0) return;
+	if (!descriptor.isParameterized) return;
+	if (ref.refs) return;
+	throw runtimeError("RUNTIME.PARAM_REF_REFS_REQUIRED", `ParamRef '${ref.name ?? "<anonymous>"}' for parameterized codec '${ref.codecId}' is missing column refs; column-aware dispatch requires { table, column } at the binding site.`, {
+		codecId: ref.codecId,
+		paramName: ref.name
+	});
+}
 
 //#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, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UpdateAst, collectOrderedParamRefs, compact, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, validateParamRefRefs, whereExprKinds };
 //# sourceMappingURL=ast.mjs.map