@prisma/orm-family-sql 0.16.0-dev.36

package/dist/builder__runtime.mjs

@@ -0,0 +1,955 @@
+import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, S as ListExpression, T as NullCheckExpr, _ as InsertAst, c as DeleteAst, g as IdentifierRef, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, t as AggregateExpr, y as JoinAst } from "./types-BgkZru_1-H7yfikSQ.mjs";
+import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
+import { a as toExpr, n as codecOf, r as createRawSql } from "./expression-RUO52bJB.mjs";
+import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-BJVJRftS.mjs";
+import { assertAnnotationsApplicable } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql/4-lanes/sql-builder/dist/runtime/index.mjs
+/**
+* Runtime wrapper around a relational-core AST expression node. Carries ScopeField metadata (codecId, nullable) so aggregate-like combinators can propagate the input codec onto their result.
+*
+* `codec` records the column-bound {@link CodecRef} when the field-proxy knows the binding — both the namespaced form (`f.user.email` → `ColumnRef`) and the top-level shortcut (`f.email` → `IdentifierRef`) stamp the ref derived from contract storage. `codecOf(expression)` exposes it for operation implementations forwarding the ref to `toExpr`.
+*/
+var ExpressionImpl = class {
+	ast;
+	returnType;
+	codec;
+	constructor(ast, returnType, codec) {
+		this.ast = ast;
+		this.returnType = returnType;
+		this.codec = codec;
+	}
+	buildAst() {
+		return this.ast;
+	}
+};
+function createFieldProxy(scope) {
+	return new Proxy({}, { get(_target, prop) {
+		if (Object.hasOwn(scope.topLevel, prop)) {
+			const topField = scope.topLevel[prop];
+			if (topField) return new ExpressionImpl(IdentifierRef.of(prop), topField, topField.codec);
+		}
+		if (Object.hasOwn(scope.namespaces, prop)) {
+			const nsFields = scope.namespaces[prop];
+			if (nsFields) return createNamespaceProxy(prop, nsFields);
+		}
+	} });
+}
+function createNamespaceProxy(namespaceName, fields) {
+	return new Proxy({}, { get(_target, prop) {
+		if (Object.hasOwn(fields, prop)) {
+			const field = fields[prop];
+			if (field) return new ExpressionImpl(ColumnRef.of(namespaceName, prop), field, field.codec);
+		}
+	} });
+}
+const BOOL_FIELD = {
+	codecId: "pg/bool@1",
+	nullable: false
+};
+const resolve = toExpr;
+/**
+* Resolve a binary-comparison operand into an AST expression, threading the column-bound side's {@link CodecRef} to the raw-value side.
+*
+* For `fns.eq(f.email, 'alice@example.com')`, `f.email` is the column-bound expression carrying a `ColumnRef` AST and a `CodecRef` derived from contract storage; the raw string operand has no codec context. By deriving the codec context from the column-bound side and forwarding it via `toExpr(value, codec)`, the resulting `ParamRef` carries the `CodecRef` that encode-side dispatch needs to materialise the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).
+*/
+function resolveOperand(operand, otherCodec) {
+	if (isExpressionLike(operand)) return operand.buildAst();
+	return toExpr(operand, otherCodec);
+}
+function isExpressionLike(value) {
+	return typeof value === "object" && value !== null && "buildAst" in value && typeof value.buildAst === "function";
+}
+/**
+* Resolves an Expression via `buildAst()`, or wraps a raw value as a `LiteralExpr` — an SQL literal inlined into the query text, not a bound parameter.
+*
+* Used for `and` / `or` operands. The usual operand is an `Expression<bool>` (e.g. the result of `fns.eq`), which this function passes through by calling `buildAst()`. The only time the raw-value branch fires is when the caller writes `fns.and(true, x)` or similar — inlining `TRUE`/`FALSE` literals lets the SQL planner statically simplify `TRUE AND x` to `x`, which it cannot do for an opaque `ParamRef`.
+*/
+function toLiteralExpr(value) {
+	if (typeof value === "object" && value !== null && "buildAst" in value && typeof value.buildAst === "function") return value.buildAst();
+	return new LiteralExpr(value);
+}
+function boolExpr(astNode) {
+	return new ExpressionImpl(astNode, BOOL_FIELD);
+}
+function binaryWithSharedCodec(a, b, build) {
+	const aCodec = codecOf(a);
+	return build(resolveOperand(a, codecOf(b)), resolveOperand(b, aCodec));
+}
+function eq(a, b) {
+	if (b === null) return boolExpr(NullCheckExpr.isNull(resolve(a)));
+	if (a === null) return boolExpr(NullCheckExpr.isNull(resolve(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("eq", l, r)));
+}
+function ne(a, b) {
+	if (b === null) return boolExpr(NullCheckExpr.isNotNull(resolve(a)));
+	if (a === null) return boolExpr(NullCheckExpr.isNotNull(resolve(b)));
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr("neq", l, r)));
+}
+function comparison(a, b, op) {
+	return boolExpr(binaryWithSharedCodec(a, b, (l, r) => new BinaryExpr(op, l, r)));
+}
+function inOrNotIn(expr, valuesOrSubquery, op) {
+	const left = expr.buildAst();
+	const leftCodec = codecOf(expr);
+	const binaryFn = op === "in" ? BinaryExpr.in : BinaryExpr.notIn;
+	if (Array.isArray(valuesOrSubquery)) {
+		const refs = valuesOrSubquery.map((v) => resolveOperand(v, leftCodec));
+		return boolExpr(binaryFn(left, ListExpression.of(refs)));
+	}
+	return boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));
+}
+function numericAgg(fn, expr) {
+	return new ExpressionImpl(AggregateExpr[fn](expr.buildAst()), {
+		codecId: expr.returnType.codecId,
+		nullable: true
+	});
+}
+function createBuiltinFunctions(rawCodecInferer) {
+	return {
+		eq: (a, b) => eq(a, b),
+		ne: (a, b) => ne(a, b),
+		gt: (a, b) => comparison(a, b, "gt"),
+		gte: (a, b) => comparison(a, b, "gte"),
+		lt: (a, b) => comparison(a, b, "lt"),
+		lte: (a, b) => comparison(a, b, "lte"),
+		and: (...exprs) => boolExpr(AndExpr.of(exprs.map(toLiteralExpr))),
+		or: (...exprs) => boolExpr(OrExpr.of(exprs.map(toLiteralExpr))),
+		exists: (subquery) => boolExpr(ExistsExpr.exists(subquery.buildAst())),
+		notExists: (subquery) => boolExpr(ExistsExpr.notExists(subquery.buildAst())),
+		in: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, "in"),
+		notIn: (expr, valuesOrSubquery) => inOrNotIn(expr, valuesOrSubquery, "notIn"),
+		raw: createRawSql(rawCodecInferer)
+	};
+}
+function createAggregateOnlyFunctions() {
+	return {
+		count: (expr) => {
+			const astExpr = expr ? expr.buildAst() : void 0;
+			return new ExpressionImpl(AggregateExpr.count(astExpr), {
+				codecId: "pg/int8@1",
+				nullable: false
+			});
+		},
+		sum: (expr) => numericAgg("sum", expr),
+		avg: (expr) => numericAgg("avg", expr),
+		min: (expr) => numericAgg("min", expr),
+		max: (expr) => numericAgg("max", expr)
+	};
+}
+function createFunctions(operations, rawCodecInferer) {
+	const builtins = createBuiltinFunctions(rawCodecInferer);
+	return new Proxy({}, { get(_target, prop) {
+		if (Object.hasOwn(builtins, prop)) return builtins[prop];
+		const op = operations[prop];
+		if (op) return op.impl;
+	} });
+}
+function createAggregateFunctions(operations, rawCodecInferer) {
+	const baseFns = createFunctions(operations, rawCodecInferer);
+	const aggregates = createAggregateOnlyFunctions();
+	return new Proxy({}, { get(_target, prop) {
+		const agg = aggregates[prop];
+		if (agg) return agg;
+		return baseFns[prop];
+	} });
+}
+function resolveTableInNamespace(storage, namespaceId, tableName) {
+	const namespace = storage.namespaces[namespaceId];
+	if (namespace === void 0) return void 0;
+	const tables = namespace.entries.table;
+	if (tables === void 0 || !Object.hasOwn(tables, tableName)) return void 0;
+	return tables[tableName];
+}
+/**
+* **Last-resort escape hatch for unsafe type assertions. Not a sanctioned tool to reach for.**
+*
+* Before reaching for `blindCast`, **rewrite the surrounding code so the cast becomes
+* unnecessary**: tighten an input type, add a runtime check that narrows via a type
+* predicate, restructure a generic so the compiler can see the relationship you're
+* asserting, or use {@link castAs} when the value already satisfies the target type.
+* Only when no rewrite is feasible does `blindCast` become the right answer — and at
+* that point, the `Reason` literal you supply must articulate the compromise in
+* language a reviewer can evaluate.
+*
+* The reviewer **will** validate the `Reason`. If it doesn't hold up under scrutiny,
+* that is not a signal to soften the reason; it is a signal to go back and solve the
+* underlying type-system problem properly. An unconvincing justification is rework,
+* not a free pass.
+*
+* `blindCast` is the auditable form of `as Foo` / `as unknown as Foo`: it bypasses
+* the compiler's checks (the input type is `unknown`, the output type is whatever the
+* caller asks for), but it forces the unsafety to be named at the call site instead of
+* smuggled in via a bare `as`. The `Reason` type parameter exists only at compile
+* time — it is not present in the emitted JavaScript — but it is grep-able and
+* visible to future readers.
+*
+* @example
+* ```typescript
+* const stringValue = blindCast<
+*   string,
+*   "JSON.parse returns `unknown`; this field is documented to be a string in the API contract"
+* >(parsed[key]);
+* ```
+*
+* @typeParam TargetType - The type the caller is asserting the input has.
+* @typeParam _Reason - A string literal describing why bypassing the type system is necessary here.
+*                     Only meaningful at compile time. The reviewer evaluates whether it justifies the unsafety.
+*/
+function blindCast(input) {
+	return input;
+}
+/**
+* Returns an object with the key/value if value is defined, otherwise an empty object.
+*
+* Use with spread to conditionally include optional properties while satisfying
+* exactOptionalPropertyTypes. This is explicit about which properties are optional
+* and won't inadvertently strip other undefined values.
+*
+* @example
+* ```typescript
+* // Instead of:
+* const obj = {
+*   required: 'value',
+*   ...(optional ? { optional } : {}),
+* };
+*
+* // Use:
+* const obj = {
+*   required: 'value',
+*   ...ifDefined('optional', optional),
+* };
+* ```
+*/
+function ifDefined(key, value) {
+	return value !== void 0 ? blindCast({ [key]: value }) : {};
+}
+function structuredError(code, message, options) {
+	const error = options?.cause !== void 0 ? new Error(message, { cause: options.cause }) : new Error(message);
+	Object.defineProperty(error, "name", {
+		value: "StructuredError",
+		configurable: true
+	});
+	return Object.assign(error, {
+		code,
+		...ifDefined("why", options?.why),
+		...ifDefined("fix", options?.fix),
+		...ifDefined("where", options?.where),
+		...ifDefined("severity", options?.severity),
+		...ifDefined("meta", options?.meta),
+		...ifDefined("docsUrl", options?.docsUrl)
+	});
+}
+var BuilderBase = class {
+	ctx;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	_gate(required, methodName, method) {
+		return ((...args) => {
+			assertCapability(this.ctx, required, methodName);
+			return method(...args);
+		});
+	}
+};
+/**
+* Derive the canonical {@link CodecRef} for a `(table, column)` from the builder context's storage. Returns `undefined` when the builder context has no storage attached or when the column is unknown to the contract.
+*/
+function codecRefFor(ctx, namespaceId, tableName, columnName) {
+	if (!ctx.storage) return void 0;
+	return codecRefForStorageColumn(ctx.storage, namespaceId, tableName, columnName);
+}
+function emptyState(from, scope) {
+	return {
+		from,
+		joins: [],
+		projections: [],
+		where: [],
+		orderBy: [],
+		groupBy: [],
+		having: void 0,
+		limit: void 0,
+		offset: void 0,
+		distinct: void 0,
+		distinctOn: void 0,
+		scope,
+		rowFields: {},
+		annotations: /* @__PURE__ */ new Map()
+	};
+}
+function cloneState(state, overrides) {
+	return {
+		...state,
+		...overrides
+	};
+}
+function combineWhereExprs(exprs) {
+	if (exprs.length === 0) return void 0;
+	if (exprs.length === 1) return exprs[0];
+	return AndExpr.of(exprs);
+}
+function buildSelectAst(state) {
+	const where = combineWhereExprs(state.where);
+	return new SelectAst({
+		from: state.from,
+		joins: state.joins.length > 0 ? state.joins : void 0,
+		projection: state.projections,
+		where,
+		orderBy: state.orderBy.length > 0 ? state.orderBy : void 0,
+		distinct: state.distinct,
+		distinctOn: state.distinctOn && state.distinctOn.length > 0 ? state.distinctOn : void 0,
+		groupBy: state.groupBy.length > 0 ? state.groupBy : void 0,
+		having: state.having,
+		limit: state.limit,
+		offset: state.offset,
+		selectAllIntent: void 0
+	});
+}
+function buildQueryPlan(ast, ctx, annotations) {
+	const paramValues = collectOrderedParamRefs(ast).map((r) => r.kind === "param-ref" ? r.value : void 0);
+	const annotationsRecord = annotations !== void 0 && annotations.size > 0 ? Object.freeze(Object.fromEntries(annotations)) : void 0;
+	const meta = Object.freeze({
+		target: ctx.target,
+		storageHash: ctx.storageHash,
+		lane: "dsl",
+		...ifDefined("annotations", annotationsRecord)
+	});
+	return Object.freeze({
+		ast,
+		params: paramValues,
+		meta
+	});
+}
+function buildPlan(state, ctx) {
+	return buildQueryPlan(buildSelectAst(state), ctx, state.annotations);
+}
+function tableToScope(alias, table, options) {
+	const storage = options?.storage;
+	const lookupName = options?.tableName;
+	const namespaceId = options?.namespaceId;
+	const fields = {};
+	for (const [colName, col] of Object.entries(table.columns)) {
+		const codec = storage && lookupName && namespaceId !== void 0 ? codecRefForStorageColumn(storage, namespaceId, lookupName, colName) : void 0;
+		fields[colName] = {
+			codecId: col.codecId,
+			nullable: col.nullable,
+			...col.many ? { many: true } : {},
+			...codec !== void 0 ? { codec } : {}
+		};
+	}
+	return {
+		topLevel: { ...fields },
+		namespaces: { [alias]: fields }
+	};
+}
+function mergeScopes(a, b) {
+	const topLevel = {};
+	for (const [k, v] of Object.entries(a.topLevel)) if (!(k in b.topLevel)) topLevel[k] = v;
+	for (const [k, v] of Object.entries(b.topLevel)) if (!(k in a.topLevel)) topLevel[k] = v;
+	return {
+		topLevel,
+		namespaces: {
+			...a.namespaces,
+			...b.namespaces
+		}
+	};
+}
+function nullableScope(scope) {
+	const mkNullable = (tbl) => {
+		const result = {};
+		for (const [k, v] of Object.entries(tbl)) result[k] = {
+			codecId: v.codecId,
+			nullable: true,
+			...v.codec !== void 0 ? { codec: v.codec } : {}
+		};
+		return result;
+	};
+	const namespaces = {};
+	for (const [k, v] of Object.entries(scope.namespaces)) namespaces[k] = mkNullable(v);
+	return {
+		topLevel: mkNullable(scope.topLevel),
+		namespaces
+	};
+}
+function orderByScopeOf(scope, rowFields) {
+	return {
+		topLevel: {
+			...scope.topLevel,
+			...rowFields
+		},
+		namespaces: scope.namespaces
+	};
+}
+function assertCapability(ctx, required, methodName) {
+	for (const [ns, keys] of Object.entries(required)) for (const key of Object.keys(keys)) if (!ctx.capabilities[ns]?.[key]) throw structuredError("ORM.CAPABILITY_MISSING", `${methodName}() requires capability ${ns}.${key}`, { meta: {
+		method: methodName,
+		capability: `${ns}.${key}`
+	} });
+}
+function resolveSelectArgs(args, scope, ctx) {
+	const projections = [];
+	const newRowFields = {};
+	if (args.length === 0) return {
+		projections,
+		newRowFields
+	};
+	if (typeof args[0] === "string" && (args.length === 1 || typeof args[1] !== "function")) {
+		for (const colName of args) {
+			const field = scope.topLevel[colName];
+			if (!field) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${colName}" not found in scope`, { meta: { column: colName } });
+			projections.push(ProjectionItem.of(colName, IdentifierRef.of(colName), field.codec));
+			newRowFields[colName] = field;
+		}
+		return {
+			projections,
+			newRowFields
+		};
+	}
+	if (typeof args[0] === "string" && typeof args[1] === "function") {
+		const alias = args[0];
+		const exprFn = args[1];
+		const fns = createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		const result = exprFn(createFieldProxy(scope), fns);
+		const field = result.returnType;
+		projections.push(ProjectionItem.of(alias, result.buildAst(), field.codec));
+		newRowFields[alias] = field;
+		return {
+			projections,
+			newRowFields
+		};
+	}
+	if (typeof args[0] === "function") {
+		const callbackFn = args[0];
+		const fns = createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		const record = callbackFn(createFieldProxy(scope), fns);
+		for (const [key, expr] of Object.entries(record)) {
+			const field = expr.returnType;
+			projections.push(ProjectionItem.of(key, expr.buildAst(), field.codec));
+			newRowFields[key] = field;
+		}
+		return {
+			projections,
+			newRowFields
+		};
+	}
+	throw structuredError("ORM.ARGUMENT_INVALID", "Invalid .select() arguments");
+}
+function resolveOrderBy(arg, options, scope, rowFields, ctx, useAggregateFns) {
+	const dir = options?.direction ?? "asc";
+	if (typeof arg === "string") {
+		if (!(arg in orderByScopeOf(scope, rowFields).topLevel)) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${arg}" not found in scope for orderBy`, { meta: { column: arg } });
+		const expr = IdentifierRef.of(arg);
+		return dir === "asc" ? OrderByItem.asc(expr) : OrderByItem.desc(expr);
+	}
+	if (typeof arg === "function") {
+		const combined = orderByScopeOf(scope, rowFields);
+		const fns = useAggregateFns ? createAggregateFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer) : createFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		const result = arg(createFieldProxy(combined), fns);
+		return dir === "asc" ? OrderByItem.asc(result.buildAst()) : OrderByItem.desc(result.buildAst());
+	}
+	throw structuredError("ORM.ARGUMENT_INVALID", "Invalid orderBy argument");
+}
+function resolveGroupBy(args, scope, rowFields, ctx) {
+	if (typeof args[0] === "string") {
+		const combined = orderByScopeOf(scope, rowFields);
+		return args.map((colName) => {
+			if (!(colName in combined.topLevel)) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${colName}" not found in scope for groupBy`, { meta: { column: colName } });
+			return IdentifierRef.of(colName);
+		});
+	}
+	if (typeof args[0] === "function") {
+		const combined = orderByScopeOf(scope, rowFields);
+		const fns = createFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		return [args[0](createFieldProxy(combined), fns).buildAst()];
+	}
+	throw structuredError("ORM.ARGUMENT_INVALID", "Invalid groupBy arguments");
+}
+function resolveDistinctOn(args, scope, rowFields, ctx) {
+	if (args.length === 1 && typeof args[0] === "function") {
+		const combined = orderByScopeOf(scope, rowFields);
+		const fns = createFunctions(ctx.queryOperationTypes, ctx.rawCodecInferer);
+		return [args[0](createFieldProxy(combined), fns).buildAst()];
+	}
+	const combined = orderByScopeOf(scope, rowFields);
+	return args.map((colName) => {
+		if (!(colName in combined.topLevel)) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${colName}" not found in scope for distinctOn`, { meta: { column: colName } });
+		return IdentifierRef.of(colName);
+	});
+}
+var QueryBase = class extends BuilderBase {
+	state;
+	constructor(state, ctx) {
+		super(ctx);
+		this.state = state;
+	}
+	distinctOn = this._gate({ postgres: { distinctOn: true } }, "distinctOn", (...args) => {
+		const exprs = resolveDistinctOn(args, this.state.scope, this.state.rowFields, this.ctx);
+		return this.clone(cloneState(this.state, { distinctOn: [...this.state.distinctOn ?? [], ...exprs] }));
+	});
+	limit(count) {
+		const limit = typeof count === "number" ? count : toExpr(count);
+		return this.clone(cloneState(this.state, { limit }));
+	}
+	offset(count) {
+		const offset = typeof count === "number" ? count : toExpr(count);
+		return this.clone(cloneState(this.state, { offset }));
+	}
+	distinct() {
+		return this.clone(cloneState(this.state, { distinct: true }));
+	}
+	/**
+	* Attach one or more annotations to this query plan.
+	*
+	* Read builders (`SelectQueryImpl`, `GroupedQueryImpl`) accept
+	* annotations whose declared `applicableTo` includes `'read'`.
+	* The type-level `As & ValidAnnotations<'read', As>` gate rejects
+	* write-only annotations at the call site; the runtime check below
+	* fails closed for callers that bypass the type gate (cast / `any`).
+	*
+	* Multiple `.annotate(...)` calls compose; duplicate namespaces use
+	* last-write-wins. The accumulated annotations are merged into
+	* `plan.meta.annotations` at `.build()` time, alongside any framework-
+	* internal metadata under reserved namespaces (e.g. `codecs`).
+	*
+	* Chainable in any position (before / after `.where`, `.select`,
+	* `.limit`, etc.); the returned builder has the same row type.
+	*/
+	annotate(...annotations) {
+		assertAnnotationsApplicable(annotations, "read", "sql-dsl.annotate");
+		const next = new Map(this.state.annotations);
+		for (const annotation of annotations) next.set(annotation.namespace, annotation);
+		return this.clone(cloneState(this.state, { annotations: next }));
+	}
+	groupBy(...args) {
+		const exprs = resolveGroupBy(args, this.state.scope, this.state.rowFields, this.ctx);
+		return new GroupedQueryImpl(cloneState(this.state, { groupBy: [...this.state.groupBy, ...exprs] }), this.ctx);
+	}
+	as(alias) {
+		const ast = buildSelectAst(this.state);
+		const derivedSource = DerivedTableSource.as(alias, ast);
+		const scope = {
+			topLevel: this.state.rowFields,
+			namespaces: { [alias]: this.state.rowFields }
+		};
+		return {
+			getJoinOuterScope: () => scope,
+			buildAst: () => derivedSource
+		};
+	}
+	getRowFields() {
+		return this.state.rowFields;
+	}
+	buildAst() {
+		return buildSelectAst(this.state);
+	}
+	build() {
+		return buildPlan(this.state, this.ctx);
+	}
+};
+var SelectQueryImpl = class SelectQueryImpl extends QueryBase {
+	clone(state) {
+		return new SelectQueryImpl(state, this.ctx);
+	}
+	select(...args) {
+		const { projections, newRowFields } = resolveSelectArgs(args, this.state.scope, this.ctx);
+		return new SelectQueryImpl(cloneState(this.state, {
+			projections: [...this.state.projections, ...projections],
+			rowFields: {
+				...this.state.rowFields,
+				...newRowFields
+			}
+		}), this.ctx);
+	}
+	where(expr) {
+		const result = expr(createFieldProxy(this.state.scope), createFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer));
+		return new SelectQueryImpl(cloneState(this.state, { where: [...this.state.where, result.buildAst()] }), this.ctx);
+	}
+	orderBy(arg, options) {
+		const item = resolveOrderBy(arg, options, this.state.scope, this.state.rowFields, this.ctx, false);
+		return this.clone(cloneState(this.state, { orderBy: [...this.state.orderBy, item] }));
+	}
+};
+var GroupedQueryImpl = class GroupedQueryImpl extends QueryBase {
+	clone(state) {
+		return new GroupedQueryImpl(state, this.ctx);
+	}
+	having(expr) {
+		const combined = orderByScopeOf(this.state.scope, this.state.rowFields);
+		const fns = createAggregateFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer);
+		const result = expr(createFieldProxy(combined), fns);
+		return new GroupedQueryImpl(cloneState(this.state, { having: result.buildAst() }), this.ctx);
+	}
+	orderBy(arg, options) {
+		const item = resolveOrderBy(arg, options, this.state.scope, this.state.rowFields, this.ctx, true);
+		return this.clone(cloneState(this.state, { orderBy: [...this.state.orderBy, item] }));
+	}
+};
+var JoinedTablesImpl = class JoinedTablesImpl extends BuilderBase {
+	#state;
+	constructor(state, ctx) {
+		super(ctx);
+		this.#state = state;
+	}
+	lateralJoin = this._gate({ sql: { lateral: true } }, "lateralJoin", (alias, builder) => {
+		const { derivedSource, lateralScope } = this.#buildLateral(alias, builder);
+		const resultScope = mergeScopes(this.#state.scope, lateralScope);
+		return this.#addLateralJoin("inner", resultScope, derivedSource);
+	});
+	outerLateralJoin = this._gate({ sql: { lateral: true } }, "outerLateralJoin", (alias, builder) => {
+		const { derivedSource, lateralScope } = this.#buildLateral(alias, builder);
+		const resultScope = mergeScopes(this.#state.scope, nullableScope(lateralScope));
+		return this.#addLateralJoin("left", resultScope, derivedSource);
+	});
+	select(...args) {
+		const { projections, newRowFields } = resolveSelectArgs(args, this.#state.scope, this.ctx);
+		return new SelectQueryImpl(cloneState(this.#state, {
+			projections: [...this.#state.projections, ...projections],
+			rowFields: {
+				...this.#state.rowFields,
+				...newRowFields
+			}
+		}), this.ctx);
+	}
+	innerJoin(other, on) {
+		const targetScope = mergeScopes(this.#state.scope, other.getJoinOuterScope());
+		return this.#addJoin(other, "inner", targetScope, on);
+	}
+	outerLeftJoin(other, on) {
+		const targetScope = mergeScopes(this.#state.scope, nullableScope(other.getJoinOuterScope()));
+		return this.#addJoin(other, "left", targetScope, on);
+	}
+	outerRightJoin(other, on) {
+		const targetScope = mergeScopes(nullableScope(this.#state.scope), other.getJoinOuterScope());
+		return this.#addJoin(other, "right", targetScope, on);
+	}
+	outerFullJoin(other, on) {
+		const targetScope = mergeScopes(nullableScope(this.#state.scope), nullableScope(other.getJoinOuterScope()));
+		return this.#addJoin(other, "full", targetScope, on);
+	}
+	#addJoin(other, joinType, resultScope, onExpr) {
+		const onResult = onExpr(createFieldProxy(mergeScopes(this.#state.scope, other.getJoinOuterScope())), createFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer));
+		const joinAst = new JoinAst(joinType, other.buildAst(), onResult.buildAst());
+		return new JoinedTablesImpl(cloneState(this.#state, {
+			joins: [...this.#state.joins, joinAst],
+			scope: resultScope
+		}), this.ctx);
+	}
+	#buildLateral(alias, builderFn) {
+		const subquery = builderFn({ from: (other) => {
+			const otherScope = other.getJoinOuterScope();
+			const parentMerged = mergeScopes(this.#state.scope, otherScope);
+			return new SelectQueryImpl(emptyState(other.buildAst(), parentMerged), this.ctx);
+		} });
+		const subqueryAst = subquery.buildAst();
+		const derivedSource = DerivedTableSource.as(alias, subqueryAst);
+		const subqueryRowFields = subquery.getRowFields();
+		return {
+			derivedSource,
+			lateralScope: {
+				topLevel: subqueryRowFields,
+				namespaces: { [alias]: subqueryRowFields }
+			}
+		};
+	}
+	#addLateralJoin(joinType, resultScope, derivedSource) {
+		const joinAst = new JoinAst(joinType, derivedSource, AndExpr.of([]), true);
+		return new JoinedTablesImpl(cloneState(this.#state, {
+			joins: [...this.#state.joins, joinAst],
+			scope: resultScope
+		}), this.ctx);
+	}
+};
+/**
+* Validates and merges a variadic annotations call into a builder's
+* accumulated user-annotations map. Used by `.annotate(...)` on each of
+* the three mutation builders (`InsertQueryImpl`, `UpdateQueryImpl`,
+* `DeleteQueryImpl`); the read builders share the same logic via
+* `QueryBase.annotate()` in `./query-impl.ts`.
+*
+* Runs `assertAnnotationsApplicable` at call time (not at `.build()`) so
+* inapplicable annotations forced through casts surface immediately
+* rather than at plan-construction time.
+*/
+function mergeWriteAnnotations(current, annotations) {
+	assertAnnotationsApplicable(annotations, "write", "sql-dsl.annotate");
+	const next = new Map(current);
+	for (const annotation of annotations) next.set(annotation.namespace, annotation);
+	return next;
+}
+function buildParamValues(values, namespaceId, table, tableName, op, ctx) {
+	const params = {};
+	for (const [col, value] of Object.entries(values)) {
+		const codec = table.columns[col] ? codecRefFor(ctx, namespaceId, tableName, col) : void 0;
+		params[col] = ParamRef.of(value, codec ? { codec } : void 0);
+	}
+	for (const def of ctx.applyMutationDefaults({
+		op,
+		namespace: namespaceId,
+		table: tableName,
+		values
+	})) {
+		const codec = table.columns[def.column] ? codecRefFor(ctx, namespaceId, tableName, def.column) : void 0;
+		params[def.column] = ParamRef.of(def.value, codec ? { codec } : void 0);
+	}
+	return params;
+}
+function buildReturningProjections(tableName, columns, rowFields) {
+	return columns.map((col) => ProjectionItem.of(col, ColumnRef.of(tableName, col), rowFields[col]?.codec));
+}
+function evaluateWhere(whereCallback, scope, queryOperationTypes, rawCodecInferer) {
+	return whereCallback(createFieldProxy(scope), createFunctions(queryOperationTypes, rawCodecInferer)).buildAst();
+}
+function evaluateUpdateCallback(callback, scope, queryOperationTypes, rawCodecInferer) {
+	const result = callback(createFieldProxy(scope), createFunctions(queryOperationTypes, rawCodecInferer));
+	const set = {};
+	for (const [col, expr] of Object.entries(result)) if (expr !== void 0) set[col] = expr.buildAst();
+	return set;
+}
+function buildSetExpressions(exprs, namespaceId, table, tableName, op, ctx) {
+	const set = { ...exprs };
+	for (const def of ctx.applyMutationDefaults({
+		op,
+		namespace: namespaceId,
+		table: tableName,
+		values: exprs
+	})) if (!(def.column in set)) {
+		const codec = table.columns[def.column] ? codecRefFor(ctx, namespaceId, tableName, def.column) : void 0;
+		set[def.column] = ParamRef.of(def.value, ifDefined("codec", codec));
+	}
+	return set;
+}
+var InsertQueryImpl = class InsertQueryImpl extends BuilderBase {
+	#tableSource;
+	#tableName;
+	#namespaceId;
+	#table;
+	#scope;
+	#rows;
+	#returningColumns;
+	#rowFields;
+	#annotations;
+	constructor(tableSource, namespaceId, table, scope, rows, ctx, returningColumns = [], rowFields = {}, annotations = /* @__PURE__ */ new Map()) {
+		super(ctx);
+		this.#tableSource = tableSource;
+		this.#tableName = tableSource.name;
+		this.#namespaceId = namespaceId;
+		this.#table = table;
+		this.#scope = scope;
+		this.#rows = rows;
+		this.#returningColumns = returningColumns;
+		this.#rowFields = rowFields;
+		this.#annotations = annotations;
+	}
+	returning = this._gate({ sql: { returning: true } }, "returning", (...columns) => {
+		const newRowFields = {};
+		for (const col of columns) {
+			const field = this.#scope.topLevel[col];
+			if (!field) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${col}" not found in scope`, { meta: { column: col } });
+			newRowFields[col] = field;
+		}
+		return new InsertQueryImpl(this.#tableSource, this.#namespaceId, this.#table, this.#scope, this.#rows, this.ctx, columns, newRowFields, this.#annotations);
+	});
+	/**
+	* Attach one or more write-typed annotations to this query plan.
+	* The type-level `As & ValidAnnotations<'write', As>` gate rejects
+	* read-only annotations at the call site; the runtime check fails
+	* closed for callers that bypass the type gate. See `QueryBase.annotate`
+	* in `./query-impl.ts` for the read-builder counterpart.
+	*/
+	annotate(...annotations) {
+		return new InsertQueryImpl(this.#tableSource, this.#namespaceId, this.#table, this.#scope, this.#rows, this.ctx, this.#returningColumns, this.#rowFields, mergeWriteAnnotations(this.#annotations, annotations));
+	}
+	build() {
+		if (this.#rows.length === 0) throw structuredError("ORM.MUTATION_DATA_MISSING", "insert() called with an empty row array — at least one row is required");
+		const paramRows = this.#rows.map((rowValues) => buildParamValues(rowValues, this.#namespaceId, this.#table, this.#tableName, "create", this.ctx));
+		let ast = InsertAst.into(this.#tableSource).withRows(paramRows);
+		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningProjections(this.#tableName, this.#returningColumns, this.#rowFields));
+		return buildQueryPlan(ast, this.ctx, this.#annotations);
+	}
+};
+var UpdateQueryImpl = class UpdateQueryImpl extends BuilderBase {
+	#tableSource;
+	#tableName;
+	#scope;
+	#setExpressions;
+	#whereExprs;
+	#returningColumns;
+	#rowFields;
+	#annotations;
+	constructor(tableSource, scope, setExpressions, ctx, whereExprs = [], returningColumns = [], rowFields = {}, annotations = /* @__PURE__ */ new Map()) {
+		super(ctx);
+		this.#tableSource = tableSource;
+		this.#tableName = tableSource.name;
+		this.#scope = scope;
+		this.#setExpressions = setExpressions;
+		this.#whereExprs = whereExprs;
+		this.#returningColumns = returningColumns;
+		this.#rowFields = rowFields;
+		this.#annotations = annotations;
+	}
+	where(expr) {
+		const result = expr(createFieldProxy(this.#scope), createFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer));
+		return new UpdateQueryImpl(this.#tableSource, this.#scope, this.#setExpressions, this.ctx, [...this.#whereExprs, result.buildAst()], this.#returningColumns, this.#rowFields, this.#annotations);
+	}
+	returning = this._gate({ sql: { returning: true } }, "returning", (...columns) => {
+		const newRowFields = {};
+		for (const col of columns) {
+			const field = this.#scope.topLevel[col];
+			if (!field) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${col}" not found in scope`, { meta: { column: col } });
+			newRowFields[col] = field;
+		}
+		return new UpdateQueryImpl(this.#tableSource, this.#scope, this.#setExpressions, this.ctx, this.#whereExprs, columns, newRowFields, this.#annotations);
+	});
+	/**
+	* Attach one or more write-typed annotations to this query plan.
+	* See `InsertQueryImpl.annotate` for semantics; the runtime check
+	* fails closed for callers that bypass the type-level gate.
+	*/
+	annotate(...annotations) {
+		return new UpdateQueryImpl(this.#tableSource, this.#scope, this.#setExpressions, this.ctx, this.#whereExprs, this.#returningColumns, this.#rowFields, mergeWriteAnnotations(this.#annotations, annotations));
+	}
+	build() {
+		let ast = UpdateAst.table(this.#tableSource).withSet(this.#setExpressions).withWhere(combineWhereExprs(this.#whereExprs));
+		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningProjections(this.#tableName, this.#returningColumns, this.#rowFields));
+		return buildQueryPlan(ast, this.ctx, this.#annotations);
+	}
+};
+var DeleteQueryImpl = class DeleteQueryImpl extends BuilderBase {
+	#tableSource;
+	#tableName;
+	#scope;
+	#whereCallbacks;
+	#returningColumns;
+	#rowFields;
+	#annotations;
+	constructor(tableSource, scope, ctx, whereCallbacks = [], returningColumns = [], rowFields = {}, annotations = /* @__PURE__ */ new Map()) {
+		super(ctx);
+		this.#tableSource = tableSource;
+		this.#tableName = tableSource.name;
+		this.#scope = scope;
+		this.#whereCallbacks = whereCallbacks;
+		this.#returningColumns = returningColumns;
+		this.#rowFields = rowFields;
+		this.#annotations = annotations;
+	}
+	where(expr) {
+		return new DeleteQueryImpl(this.#tableSource, this.#scope, this.ctx, [...this.#whereCallbacks, expr], this.#returningColumns, this.#rowFields, this.#annotations);
+	}
+	returning = this._gate({ sql: { returning: true } }, "returning", (...columns) => {
+		const newRowFields = {};
+		for (const col of columns) {
+			const field = this.#scope.topLevel[col];
+			if (!field) throw structuredError("ORM.COLUMN_UNKNOWN", `Column "${col}" not found in scope`, { meta: { column: col } });
+			newRowFields[col] = field;
+		}
+		return new DeleteQueryImpl(this.#tableSource, this.#scope, this.ctx, this.#whereCallbacks, columns, newRowFields, this.#annotations);
+	});
+	/**
+	* Attach one or more write-typed annotations to this query plan.
+	* See `InsertQueryImpl.annotate` for semantics.
+	*/
+	annotate(...annotations) {
+		return new DeleteQueryImpl(this.#tableSource, this.#scope, this.ctx, this.#whereCallbacks, this.#returningColumns, this.#rowFields, mergeWriteAnnotations(this.#annotations, annotations));
+	}
+	build() {
+		const whereExpr = combineWhereExprs(this.#whereCallbacks.map((cb) => evaluateWhere(cb, this.#scope, this.ctx.queryOperationTypes, this.ctx.rawCodecInferer)));
+		let ast = DeleteAst.from(this.#tableSource).withWhere(whereExpr);
+		if (this.#returningColumns.length > 0) ast = ast.withReturning(buildReturningProjections(this.#tableName, this.#returningColumns, this.#rowFields));
+		return buildQueryPlan(ast, this.ctx, this.#annotations);
+	}
+};
+function tableSourceForProxy(tableName, alias, namespaceId) {
+	return TableSource.named(tableName, alias !== tableName ? alias : void 0, namespaceId);
+}
+var TableProxyImpl = class TableProxyImpl extends BuilderBase {
+	#tableName;
+	#table;
+	#namespaceId;
+	#fromSource;
+	#scope;
+	constructor(tableName, table, alias, ctx, namespaceId) {
+		super(ctx);
+		this.#tableName = tableName;
+		this.#table = table;
+		this.#namespaceId = namespaceId;
+		this.#scope = tableToScope(alias, table, {
+			storage: ctx.storage,
+			tableName,
+			namespaceId
+		});
+		this.#fromSource = tableSourceForProxy(tableName, alias, namespaceId);
+	}
+	lateralJoin = this._gate({ sql: { lateral: true } }, "lateralJoin", (alias, builder) => {
+		return this.#toJoined().lateralJoin(alias, builder);
+	});
+	outerLateralJoin = this._gate({ sql: { lateral: true } }, "outerLateralJoin", (alias, builder) => {
+		return this.#toJoined().outerLateralJoin(alias, builder);
+	});
+	getJoinOuterScope() {
+		return this.#scope;
+	}
+	buildAst() {
+		return this.#fromSource;
+	}
+	as(newAlias) {
+		return new TableProxyImpl(this.#tableName, this.#table, newAlias, this.ctx, this.#namespaceId);
+	}
+	select(...args) {
+		return new SelectQueryImpl(emptyState(this.#fromSource, this.#scope), this.ctx).select(...args);
+	}
+	innerJoin(other, on) {
+		return this.#toJoined().innerJoin(other, on);
+	}
+	outerLeftJoin(other, on) {
+		return this.#toJoined().outerLeftJoin(other, on);
+	}
+	outerRightJoin(other, on) {
+		return this.#toJoined().outerRightJoin(other, on);
+	}
+	outerFullJoin(other, on) {
+		return this.#toJoined().outerFullJoin(other, on);
+	}
+	insert(rows) {
+		return new InsertQueryImpl(this.#fromSource, this.#namespaceId, this.#table, this.#scope, rows, this.ctx);
+	}
+	update(setOrCallback) {
+		if (typeof setOrCallback === "function") {
+			const setExpressions = buildSetExpressions(evaluateUpdateCallback(setOrCallback, this.#scope, this.ctx.queryOperationTypes, this.ctx.rawCodecInferer), this.#namespaceId, this.#table, this.#tableName, "update", this.ctx);
+			return new UpdateQueryImpl(this.#fromSource, this.#scope, setExpressions, this.ctx);
+		}
+		const setExpressions = buildParamValues(setOrCallback, this.#namespaceId, this.#table, this.#tableName, "update", this.ctx);
+		return new UpdateQueryImpl(this.#fromSource, this.#scope, setExpressions, this.ctx);
+	}
+	delete() {
+		return new DeleteQueryImpl(this.#fromSource, this.#scope, this.ctx);
+	}
+	#toJoined() {
+		return new JoinedTablesImpl(emptyState(this.#fromSource, this.#scope), this.ctx);
+	}
+};
+function sql(options) {
+	const { context, rawCodecInferer } = options;
+	const ctx = {
+		capabilities: context.contract.capabilities,
+		queryOperationTypes: context.queryOperations.entries(),
+		target: context.contract.target ?? "unknown",
+		storageHash: context.contract.storage.storageHash ?? "unknown",
+		storage: context.contract.storage,
+		applyMutationDefaults: (options) => context.applyMutationDefaults(options),
+		rawCodecInferer
+	};
+	const { storage } = context.contract;
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return;
+		if (!Object.hasOwn(storage.namespaces, prop)) return;
+		const namespaceId = prop;
+		return new Proxy({}, { get(_facetTarget, tableName) {
+			if (typeof tableName !== "string") return;
+			const table = resolveTableInNamespace(storage, namespaceId, tableName);
+			if (table) return new TableProxyImpl(tableName, table, tableName, ctx, namespaceId);
+		} });
+	} });
+}
+//#endregion
+export { ExpressionImpl, createAggregateFunctions, createFieldProxy, createFunctions, sql };
+
+//# sourceMappingURL=builder__runtime.mjs.map