@dbsp/adapter-pgsql 1.2.0 → 1.3.0

package/dist/index.js

@@ -1355,7 +1355,9 @@ function compileExpressionIntent(intent, ctx, state) {
     }
     case "relationColumn": {
       const rc = intent;
-      const alias = state.aliases.get(rc.relation) ?? rc.relation;
+      const relationSegments = rc.relation.split(".");
+      const leaf = relationSegments[relationSegments.length - 1] ?? rc.relation;
+      const alias = state.aliases.get(rc.relation) ?? state.aliases.get(leaf) ?? leaf;
       return columnRef(rc.column, alias, void 0, ctx.naming);
     }
     case "case": {
@@ -2814,8 +2816,9 @@ var init_param_intent = __esm({
 import { isFieldRef, isParamIntent as isParamIntent3 } from "@dbsp/types";
 function buildColumnRef(column, ctx) {
   if (column.includes(".")) {
-    const dotIndex = column.indexOf(".");
-    const table = column.substring(0, dotIndex);
+    const dotIndex = column.lastIndexOf(".");
+    const relation = column.substring(0, dotIndex);
+    const table = ctx.aliases?.get(relation) ?? relation;
     const col = column.substring(dotIndex + 1);
     return columnRef(col, table, void 0, ctx.naming);
   }
@@ -3648,6 +3651,27 @@ var init_range = __esm({
   }
 });
 
+// src/binding-registry.ts
+function emittedBindName(name, naming) {
+  return naming.toDatabase(name);
+}
+function hasBindingName(bindingNames, name, naming) {
+  return bindingNames?.has(emittedBindName(name, naming)) ?? false;
+}
+function schemaForFromName(schemaName, fromName, bindingNames, naming) {
+  return hasBindingName(bindingNames, fromName, naming) ? void 0 : schemaName;
+}
+function withBindingName(bindingNames, name, naming) {
+  const next = new Set(bindingNames ?? []);
+  next.add(emittedBindName(name, naming));
+  return next;
+}
+var init_binding_registry = __esm({
+  "src/binding-registry.ts"() {
+    "use strict";
+  }
+});
+
 // src/compile-where.ts
 function toHandlerContext(ctx) {
   return {
@@ -3656,11 +3680,12 @@ function toHandlerContext(ctx) {
     currentAlias: ctx.currentAlias ?? ctx.rootTable,
     maxRecursiveDepth: 100,
     ...ctx.schemaName !== void 0 && { schema: ctx.schemaName },
+    ...ctx.bindingNames !== void 0 && { bindingNames: ctx.bindingNames },
     ...ctx.model !== void 0 && { model: ctx.model },
     ...ctx.outerTable !== void 0 && { outerAlias: ctx.outerTable }
   };
 }
-function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, schemaName, use = "rawExists") {
+function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, schemaName, use = "rawExists", bindingNames) {
   assertNoUnsupportedSubqueryModifiers(intent, use);
   if (intent.where && containsOuterRef(intent.where)) {
     throw new Error(
@@ -3705,9 +3730,14 @@ function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, s
   }
   const stmt = {
     targetList,
-    // Bug 3 fix: propagate schema name from outer context so schema-scoped
-    // queries generate "schema"."table" AS alias instead of bare "table" AS alias.
-    fromClause: [rangeVar(targetTable, innerAlias, schemaName, naming)]
+    fromClause: [
+      rangeVar(
+        targetTable,
+        innerAlias,
+        schemaForFromName(schemaName, targetTable, bindingNames, naming),
+        naming
+      )
+    ]
   };
   let paramCount = 0;
   let innerParameters = [];
@@ -3721,6 +3751,7 @@ function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, s
       aliases: /* @__PURE__ */ new Map(),
       paramState: innerState,
       naming,
+      ...bindingNames !== void 0 && { bindingNames },
       compileSubquery: (_nestedIntent, _nestedOffset) => {
         throw new Error(
           "buildSubqueryFromIntent: nested subquery not supported"
@@ -4098,6 +4129,7 @@ var init_compile_where = __esm({
     init_custom();
     init_handlers();
     init_assert_field();
+    init_binding_registry();
     init_types();
     init_utils();
     init_intent_to_decisions();
@@ -4142,7 +4174,8 @@ var init_raw_exists = __esm({
           state.paramIndex,
           ctx.naming,
           ctx.schema,
-          "rawExists"
+          "rawExists",
+          ctx.bindingNames
         );
         if (innerParams) {
           for (const p of innerParams) {
@@ -4378,7 +4411,19 @@ function buildPredicateSubquerySelect(use, sourceIntent, decision, ctx, state, d
   }
   const stmt = {
     targetList: [{ ResTarget: { val: targetVal } }],
-    fromClause: [rangeVar(targetTable, targetAlias, ctx.schema, ctx.naming)],
+    fromClause: [
+      rangeVar(
+        targetTable,
+        targetAlias,
+        schemaForFromName(
+          ctx.schema,
+          targetTable,
+          ctx.bindingNames,
+          ctx.naming
+        ),
+        ctx.naming
+      )
+    ],
     ...whereClause && { whereClause }
   };
   if (decision.orderBy && decision.orderBy.length > 0) {
@@ -4415,6 +4460,7 @@ var init_subquery_emission = __esm({
   "src/subquery-emission.ts"() {
     "use strict";
     init_ast_helpers();
+    init_binding_registry();
     init_intent_to_decisions();
     init_param_intent();
   }
@@ -6685,7 +6731,7 @@ var init_relation = __esm({
         if (relation.includes(".")) {
           const segments = relation.split(".");
           const leaf = segments[segments.length - 1];
-          alias = state.aliases.get(leaf) ?? state.aliases.get(relation) ?? leaf;
+          alias = state.aliases.get(relation) ?? state.aliases.get(leaf) ?? leaf;
         } else {
           alias = state.aliases.get(relation) ?? relation;
         }
@@ -7047,6 +7093,7 @@ import {
   NQL_SELECT_SCALAR_FUNCTION_ALLOWLIST,
   NQL_SELECT_WINDOW_FUNCTION_ALLOWLIST
 } from "@dbsp/types";
+import { getNqlBindingRefName, isNqlBindingRef } from "@dbsp/types/internal";
 
 // src/pgsql-deparser.ts
 function deparse(node) {
@@ -8333,6 +8380,7 @@ var PlanCompiler = class _PlanCompiler {
   defaultPk;
   deriveFk;
   model;
+  bindingNames;
   /** Mutable state shared with extracted condition/value compilation functions */
   state = {
     parameters: [],
@@ -8357,6 +8405,7 @@ var PlanCompiler = class _PlanCompiler {
   joinAliasMap = /* @__PURE__ */ new Map();
   /**
    * Tracks all join aliases in use for the current query.
+   * Entries are stored in emitted database-alias space, after naming.toDatabase().
    * Ensures no two JOINs share the same alias (DOUBLE-ALIAS prevention).
    */
   usedJoinAliases = /* @__PURE__ */ new Set();
@@ -8366,16 +8415,19 @@ var PlanCompiler = class _PlanCompiler {
     this.defaultPk = options.defaultPkColumnName ?? DEFAULT_PK_COLUMN;
     this.deriveFk = options.deriveFkColumnName ?? defaultFkDerivation;
     this.model = options.model ?? void 0;
+    this.bindingNames = options.bindingNames;
   }
   /** Build immutable context for handler-based WHERE compilation */
   handlerCtx() {
     return {
       naming: this.naming,
       rootTable: this.currentRootTable,
+      aliases: this.resolvedJoinAliases(),
       maxRecursiveDepth: 100,
       defaultPkColumnName: this.defaultPk,
       deriveFkColumnName: this.deriveFk,
       ...this.schema != null && { schema: this.schema },
+      ...this.bindingNames != null && { bindingNames: this.bindingNames },
       ...this.model != null && { model: this.model }
     };
   }
@@ -8386,6 +8438,24 @@ var PlanCompiler = class _PlanCompiler {
     }
     return alias;
   }
+  emittedJoinAlias(alias) {
+    const dbAlias = this.naming.toDatabase(alias);
+    validateIdentifier(dbAlias, "alias");
+    return dbAlias;
+  }
+  resolvedJoinAliases() {
+    const aliases = /* @__PURE__ */ new Map();
+    for (const [relationPath, entry] of this.joinAliasMap) {
+      const isLegacyPath = relationPath.startsWith("__legacy__:");
+      if (!isLegacyPath) {
+        aliases.set(relationPath, entry.alias);
+      }
+      if (entry.relationName && (isLegacyPath || relationPath === entry.relationName)) {
+        aliases.set(entry.relationName, entry.alias);
+      }
+    }
+    return aliases;
+  }
   /**
    * Dispatch a PlanDecision through the unified WHERE handler system.
    * Bridges PlanCompiler's state to handler types, calls dispatcher, syncs back.
@@ -8567,12 +8637,13 @@ var PlanCompiler = class _PlanCompiler {
       const candidateAlias = handlerDecision.relation ?? handlerDecision.targetTable ?? handlerDecision.relationName;
       if (candidateAlias) {
         let alias = candidateAlias;
+        let emittedAlias = this.emittedJoinAlias(alias);
         let counter = 1;
-        while (this.usedJoinAliases.has(alias)) {
+        while (this.usedJoinAliases.has(emittedAlias)) {
           alias = `${candidateAlias}_${counter++}`;
+          emittedAlias = this.emittedJoinAlias(alias);
         }
-        validateIdentifier(alias, "alias");
-        this.usedJoinAliases.add(alias);
+        this.usedJoinAliases.add(emittedAlias);
         finalJoinAlias = alias;
         if (alias !== candidateAlias) {
           handlerDecision.relation = alias;
@@ -8585,7 +8656,10 @@ var PlanCompiler = class _PlanCompiler {
       this.joinAliasMap.set(relationIdentityPath, {
         alias: finalJoinAlias,
         joinType: requestedJoinType,
-        ...decision.targetTable && { targetTable: decision.targetTable }
+        ...decision.targetTable && { targetTable: decision.targetTable },
+        ...(decision.relationName ?? decision.relation) && {
+          relationName: decision.relationName ?? decision.relation
+        }
       });
     }
     const out = {};
@@ -8658,10 +8732,12 @@ var PlanCompiler = class _PlanCompiler {
       naming: this.naming,
       rootTable: plan.rootTable,
       currentAlias: currentAlias ?? plan.rootTable,
+      aliases: this.resolvedJoinAliases(),
       maxRecursiveDepth: 100,
       defaultPkColumnName: this.defaultPk,
       deriveFkColumnName: this.deriveFk,
       ...plan.schema ?? this.schema ? { schema: plan.schema ?? this.schema } : {},
+      ...this.bindingNames != null && { bindingNames: this.bindingNames },
       ...this.model != null && { model: this.model },
       compileSubquery: (query, paramOffset) => this.compileExpressionSubquery(query, paramOffset),
       compileNqlSelectExpression: (value, handlerCtx, state) => this.compileNqlFunctionArg(value, handlerCtx, state)
@@ -8673,7 +8749,7 @@ var PlanCompiler = class _PlanCompiler {
       parameters: this.state.parameters,
       paramIndex: this.state.paramIndex,
       ctes: /* @__PURE__ */ new Map(),
-      aliases: /* @__PURE__ */ new Map(),
+      aliases: this.resolvedJoinAliases(),
       joins: []
     };
   }
@@ -8684,7 +8760,10 @@ var PlanCompiler = class _PlanCompiler {
         schema: this.schema
       },
       defaultPkColumnName: this.defaultPk,
-      deriveFkColumnName: this.deriveFk
+      deriveFkColumnName: this.deriveFk,
+      ...this.bindingNames !== void 0 && {
+        bindingNames: this.bindingNames
+      }
     });
     const innerPlan = {
       rootTable: query.from,
@@ -8703,14 +8782,14 @@ var PlanCompiler = class _PlanCompiler {
     return funcCall(functionName, argNodes);
   }
   compileNqlFunctionArg(arg, ctx, state) {
+    if (isNqlBindingRef(arg)) {
+      return buildColumnRef(getNqlBindingRefName(arg), ctx);
+    }
     if (typeof arg === "string") {
       return buildColumnRef(arg, ctx);
     }
     if (typeof arg === "object" && arg !== null) {
       const record = arg;
-      if (typeof record.$ref === "string") {
-        return buildColumnRef(record.$ref, ctx);
-      }
       if (typeof record.kind !== "string") {
         const legacyKind = typeof record.$op === "string" ? `$op:${record.$op}` : typeof record.$fn === "string" ? `$fn:${record.$fn}` : "object";
         throw new UnhandledNqlSelectExpressionKindError(legacyKind);
@@ -9131,11 +9210,7 @@ var PlanCompiler = class _PlanCompiler {
    * Compile an includeStrategy decision and register its results.
    * Pushes targets onto targetList, raw joins / CTEs onto instance collections.
    */
-  compileIncludeDecision(decision, plan, targetList) {
-    const includeResult = this.compileIncludeViaHandler(decision, plan);
-    if (includeResult.targets) {
-      targetList.push(...includeResult.targets);
-    }
+  registerIncludeCompilationResult(includeResult) {
     if (includeResult.rawJoin) {
       this.rawJoins.push(includeResult.rawJoin);
     }
@@ -9146,6 +9221,27 @@ var PlanCompiler = class _PlanCompiler {
       this.pendingCtes.push(includeResult.cte);
     }
   }
+  compileIncludeDecision(decision, plan, targetList, precompiled) {
+    const includeResult = precompiled ?? this.compileIncludeViaHandler(decision, plan);
+    if (includeResult.targets) {
+      targetList.push(...includeResult.targets);
+    }
+    if (!precompiled) {
+      this.registerIncludeCompilationResult(includeResult);
+    }
+  }
+  compileJoinIncludeAllocationPass(decisions, plan) {
+    const includeResults = /* @__PURE__ */ new Map();
+    for (const decision of decisions) {
+      if (decision.type !== "includeStrategy" || decision.choice !== "join") {
+        continue;
+      }
+      const includeResult = this.compileIncludeViaHandler(decision, plan);
+      includeResults.set(decision, includeResult);
+      this.registerIncludeCompilationResult(includeResult);
+    }
+    return includeResults;
+  }
   /**
    * Fold a WHERE-family decision into an existing where expression.
    * Returns the updated (or new) where node.
@@ -9279,6 +9375,14 @@ var PlanCompiler = class _PlanCompiler {
     }
     return where;
   }
+  reserveManualJoinAliases(decisions) {
+    for (const decision of decisions) {
+      if (decision.type !== "join") continue;
+      const alias = decision.alias ?? decision.targetTable;
+      if (!alias) continue;
+      this.usedJoinAliases.add(this.emittedJoinAlias(alias));
+    }
+  }
   /**
    * Apply a single join decision to the FROM clause in-place.
    * Chains multiple joins by wrapping from[0] as the left-arg each time.
@@ -9337,22 +9441,35 @@ var PlanCompiler = class _PlanCompiler {
     }
     return void 0;
   }
+  /**
+   * Compile a column reference that may use dotted 'relation.column' notation.
+   */
+  compileRelationAwareColumnRef(column, table) {
+    const dot = column.lastIndexOf(".");
+    if (dot !== -1) {
+      const relation = column.slice(0, dot);
+      const alias = this.resolvedJoinAliases().get(relation) ?? relation;
+      return columnRef(column.slice(dot + 1), alias, void 0, this.naming);
+    }
+    return columnRef(column, table, void 0, this.naming);
+  }
   /**
    * Compile a single groupBy decision into a ColumnRef AST node.
    * Supports dotted 'relation.column' notation for joined tables.
    */
   compileGroupByDecision(decision) {
-    const gbCol = decision.column;
-    const gbDot = gbCol.indexOf(".");
-    if (gbDot !== -1) {
-      return columnRef(
-        gbCol.slice(gbDot + 1),
-        gbCol.slice(0, gbDot),
-        void 0,
-        this.naming
-      );
-    }
-    return columnRef(gbCol, decision.table, void 0, this.naming);
+    return this.compileRelationAwareColumnRef(
+      decision.column,
+      decision.table
+    );
+  }
+  /**
+   * Compile a DISTINCT ON column into a ColumnRef AST node.
+   * Mirrors GROUP BY relation-alias resolution while preserving unqualified
+   * DISTINCT ON columns as unqualified references.
+   */
+  compileDistinctOnColumn(column) {
+    return this.compileRelationAwareColumnRef(column, void 0);
   }
   /**
    * Assemble the final SelectStmt from all accumulated clause nodes.
@@ -9400,10 +9517,17 @@ var PlanCompiler = class _PlanCompiler {
       plan.decisions,
       plan.rootTable
     );
+    this.reserveManualJoinAliases(decisions);
+    const includeJoinResults = this.compileJoinIncludeAllocationPass(
+      decisions,
+      plan
+    );
+    this.state.aliases = this.resolvedJoinAliases();
     const targetList = [];
     const from = this.compileFromClause(plan);
     let where;
     const orderBy = [];
+    const orderByDecisions = [];
     const groupBy = [];
     let having;
     let limit;
@@ -9423,7 +9547,12 @@ var PlanCompiler = class _PlanCompiler {
           this.compileSelectTarget(decision, plan, targetList);
           break;
         case "includeStrategy":
-          this.compileIncludeDecision(decision, plan, targetList);
+          this.compileIncludeDecision(
+            decision,
+            plan,
+            targetList,
+            includeJoinResults.get(decision)
+          );
           where = this.compileIncludeWhereConditions(decision, where);
           break;
         case "where":
@@ -9436,8 +9565,7 @@ var PlanCompiler = class _PlanCompiler {
           this.compileJoinDecision(decision, plan, from);
           break;
         case "orderBy": {
-          const obNode = this.compileOrderByDecision(decision, plan);
-          if (obNode) orderBy.push(obNode);
+          orderByDecisions.push(decision);
           break;
         }
         case "groupBy":
@@ -9478,12 +9606,16 @@ var PlanCompiler = class _PlanCompiler {
         case "distinctOn":
           if (decision.columns && decision.columns.length > 0) {
             distinct = decision.columns.map(
-              (col) => columnRef(col, void 0, void 0, this.naming)
+              (col) => this.compileDistinctOnColumn(col)
             );
           }
           break;
       }
     }
+    for (const decision of orderByDecisions) {
+      const obNode = this.compileOrderByDecision(decision, plan);
+      if (obNode) orderBy.push(obNode);
+    }
     this.flushPendingJoins(from, plan);
     return this.buildSelectStmt(
       targetList,
@@ -13074,6 +13206,7 @@ function matchGlob(pattern, value) {
 
 // src/mutations/mutation-compiler.ts
 init_ast_helpers();
+init_binding_registry();
 init_compiler_utils();
 init_handlers();
 init_param_intent();
@@ -13299,12 +13432,18 @@ function compileInsertFrom(config, ctx, state) {
   const _dbTargetTable = naming.toDatabase(config.targetTable);
   const dbSourceTable = naming.toDatabase(config.sourceTable);
   const sourceAlias = config.sourceTable;
+  const sourceSchema = schemaForFromName(
+    ctx.schema,
+    config.sourceTable,
+    ctx.bindingNames,
+    naming
+  );
   const dbColumns = config.columns?.map((c) => naming.toDatabase(c));
   let targetList;
   if (config.columns && config.columns.length > 0) {
     targetList = config.columns.map(
       (col) => resTarget(
-        columnRef(col, sourceAlias, ctx.schema, naming),
+        columnRef(col, sourceAlias, sourceSchema, naming),
         naming.toDatabase(col)
       )
     );
@@ -13344,8 +13483,8 @@ function compileInsertFrom(config, ctx, state) {
     inh: true,
     relpersistence: "p"
   };
-  if (ctx.schema) {
-    sourceRelation.schemaname = naming.toDatabase(ctx.schema);
+  if (sourceSchema) {
+    sourceRelation.schemaname = naming.toDatabase(sourceSchema);
   }
   const selectQuery = {
     SelectStmt: {
@@ -13374,12 +13513,18 @@ function compileUpsertFrom(config, ctx, state) {
   const naming = ctx.naming;
   const dbSourceTable = naming.toDatabase(config.sourceTable);
   const sourceAlias = config.sourceTable;
+  const sourceSchema = schemaForFromName(
+    ctx.schema,
+    config.sourceTable,
+    ctx.bindingNames,
+    naming
+  );
   const dbColumns = config.columns?.map((c) => naming.toDatabase(c));
   let targetList;
   if (config.columns && config.columns.length > 0) {
     targetList = config.columns.map(
       (col) => resTarget(
-        columnRef(col, sourceAlias, ctx.schema, naming),
+        columnRef(col, sourceAlias, sourceSchema, naming),
         naming.toDatabase(col)
       )
     );
@@ -13419,8 +13564,8 @@ function compileUpsertFrom(config, ctx, state) {
     inh: true,
     relpersistence: "p"
   };
-  if (ctx.schema) {
-    sourceRelation.schemaname = naming.toDatabase(ctx.schema);
+  if (sourceSchema) {
+    sourceRelation.schemaname = naming.toDatabase(sourceSchema);
   }
   const selectQuery = {
     SelectStmt: {
@@ -13565,6 +13710,28 @@ init_compiler_utils();
 init_handlers();
 init_param_intent();
 init_param_ref();
+function buildWhereClause(conditions, ctx, state) {
+  if (!conditions || conditions.length === 0) return void 0;
+  const dispatch = createWhereDispatcher();
+  if (conditions.length === 1) {
+    return dispatch(conditions[0], ctx, state);
+  }
+  const nodes = conditions.map((condition) => dispatch(condition, ctx, state));
+  return {
+    BoolExpr: { boolop: "AND_EXPR", args: nodes }
+  };
+}
+function buildActionWhereClause(config, ctx, state) {
+  if (config.actionWhereIntent) {
+    if (!config.compileActionWhere) {
+      throw new Error(
+        "Upsert actionWhereIntent requires compileActionWhere callback"
+      );
+    }
+    return config.compileActionWhere(config.actionWhereIntent, state);
+  }
+  return buildWhereClause(config.actionWhere, ctx, state);
+}
 function buildOnConflictClause(config, ctx, state) {
   const naming = ctx.naming;
   const action = config.conflictAction;
@@ -13578,18 +13745,12 @@ function buildOnConflictClause(config, ctx, state) {
       }))
     };
     if (config.conflictTarget.where && config.conflictTarget.where.length > 0) {
-      const dispatch = createWhereDispatcher();
-      const conditions = config.conflictTarget.where;
-      let whereClause;
-      if (conditions.length === 1) {
-        whereClause = dispatch(conditions[0], ctx, state);
-      } else {
-        const nodes = conditions.map((c) => dispatch(c, ctx, state));
-        whereClause = {
-          BoolExpr: { boolop: "AND_EXPR", args: nodes }
-        };
-      }
-      infer.whereClause = whereClause;
+      const whereClause2 = buildWhereClause(
+        config.conflictTarget.where,
+        ctx,
+        state
+      );
+      if (whereClause2) infer.whereClause = whereClause2;
     }
   } else if (config.conflictTarget.constraint) {
     infer = {
@@ -13635,10 +13796,12 @@ function buildOnConflictClause(config, ctx, state) {
       }
     };
   });
+  const whereClause = buildActionWhereClause(config, ctx, state);
   return {
     action: "ONCONFLICT_UPDATE",
     ...infer && { infer },
-    targetList
+    targetList,
+    ...whereClause && { whereClause }
   };
 }
 function compileUpsert(config, ctx, state) {
@@ -13776,7 +13939,8 @@ init_naming_plugin();
 init_param_ref();
 
 // src/pgsql-adapter.ts
-import { POSTGRESQL_CAPABILITIES, plan as planFn } from "@dbsp/core";
+import { POSTGRESQL_CAPABILITIES as POSTGRESQL_CAPABILITIES2, plan as planFn2 } from "@dbsp/core";
+import { getNqlBindingRefName as getNqlBindingRefName2, isNqlBindingRef as isNqlBindingRef2 } from "@dbsp/types/internal";
 
 // src/adapter-compiler-includes.ts
 init_ast_helpers();
@@ -13962,449 +14126,97 @@ function compileSubqueryIncludeManyToMany(info, parentIds, schemaName, state, de
 }
 
 // src/adapter-compiler-mutations.ts
+import {
+  InvalidOperationError as InvalidOperationError3,
+  isSqlRaw as isSqlRaw2,
+  POSTGRESQL_CAPABILITIES,
+  plan as planFn
+} from "@dbsp/core";
+
+// src/adapter-compiler-select.ts
+init_assert_field();
+init_ast_helpers();
 init_compile_where();
+import { countDistinctRelationPathsByName } from "@dbsp/core";
 init_compiler_utils();
-import { InvalidOperationError as InvalidOperationError3, isSqlRaw as isSqlRaw2 } from "@dbsp/core";
-init_handlers();
-function whereIntentAsDecision(where) {
-  return where;
-}
-function resolveExistsRelation(sourceTable, relation, model) {
-  if (!model) return { targetTable: relation };
-  const rel = model.getRelation(`${sourceTable}.${relation}`);
-  if (!rel) return { targetTable: relation };
-  const targetTable = rel.target;
-  if (rel.type === "belongsTo") {
-    const fk = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
-    return {
-      targetTable,
-      ...fk !== void 0 && { sourceColumn: fk },
-      targetColumn: "id"
-    };
-  }
-  return { targetTable };
-}
-function resolveExistsIntent(where, sourceTable, deps) {
+init_types();
+init_intent_to_decisions();
+init_param_ref();
+
+// src/plan-decision-extractor.ts
+init_assert_field();
+init_intent_to_decisions();
+import { deriveRelationPathFromIntentPath } from "@dbsp/core";
+function findExistsIntents(where) {
+  if (!where || typeof where !== "object") return [];
   const w = where;
-  const kind = w.kind;
-  if (kind === "and" || kind === "or") {
-    const conditions = w.conditions;
-    if (!conditions) return where;
-    const enriched = conditions.map(
-      (c) => resolveExistsIntent(c, sourceTable, deps)
-    );
-    const changed = enriched.some((c, i) => c !== conditions[i]);
-    return changed ? { ...w, conditions: enriched } : where;
-  }
-  if (kind === "not") {
-    const condition = w.condition;
-    if (!condition) return where;
-    const enriched = resolveExistsIntent(condition, sourceTable, deps);
-    return enriched !== condition ? { ...w, condition: enriched } : where;
+  if (w.kind === "exists" || w.kind === "notExists" || w.kind === "relationFilter") {
+    return [w];
   }
-  if (kind !== "exists" && kind !== "notExists") return where;
-  const relation = w.relation;
-  const resolved = resolveExistsRelation(sourceTable, relation, deps.model);
-  if (resolved.targetTable === relation && !resolved.sourceColumn) return where;
-  return {
-    ...w,
-    targetTable: resolved.targetTable,
-    ...resolved.sourceColumn !== void 0 && {
-      sourceColumn: resolved.sourceColumn
-    },
-    ...resolved.targetColumn !== void 0 && {
-      targetColumn: resolved.targetColumn
+  const results = [];
+  if (w.conditions && Array.isArray(w.conditions)) {
+    for (const c of w.conditions) {
+      results.push(...findExistsIntents(c));
     }
-  };
+  }
+  if (w.condition) {
+    results.push(...findExistsIntents(w.condition));
+  }
+  return results;
 }
-function getColumnTypes(tableName, columns, deps) {
-  if (!deps.model) return void 0;
-  const table = deps.model.getTable(tableName);
-  if (!table) return void 0;
-  let result;
-  for (const col of columns) {
-    const columnIR = table.columns.find((c) => c.name === col);
-    if (columnIR) {
-      result ??= {};
-      result[col] = columnIR.originalDbType ?? columnIR.type;
+function resolveRelation(model, sourceTable, relationName) {
+  const rel = model.getRelation(`${sourceTable}.${relationName}`);
+  if (!rel) return void 0;
+  const foreignKey = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
+  const relationType = rel.type;
+  return { target: rel.target, foreignKey, relationType };
+}
+function resolveIncludeAlias(context) {
+  return context.relation ?? context.includeAlias;
+}
+function resolveIncludeByPath(includes, intentPath, relationName) {
+  if (!includes) return void 0;
+  if (intentPath) {
+    const indexPattern = /include\[(\d+)\]/g;
+    let current = includes;
+    let resolved;
+    let execResult = indexPattern.exec(intentPath);
+    while (execResult !== null) {
+      const idx = parseInt(execResult[1], 10);
+      const item = current[idx];
+      if (!item) break;
+      resolved = item;
+      current = item.include ?? [];
+      execResult = indexPattern.exec(intentPath);
     }
+    if (resolved) return resolved;
   }
-  return result;
+  return includes.find(
+    (i) => i.relation === relationName || i.via === relationName
+  );
 }
-function compileInsert2(intent, options, deps) {
-  const schemaName = deps.schemaName;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.table,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100
-  };
-  const state = createCompilerState();
-  const firstRow = intent.values?.[0] ?? {};
-  const columns = Object.keys(firstRow);
-  const rows = intent.values ?? [];
-  const values = rows.map((row) => columns.map((col) => row[col]));
-  const columnTypes = getColumnTypes(intent.table, columns, deps);
-  const config = {
-    table: intent.table,
-    columns,
-    values,
-    ...intent.returning && { returning: [...intent.returning] },
-    ...columnTypes && { columnTypes }
-  };
-  const maxBatchSize = options?.maxBatchSize;
-  if (maxBatchSize !== void 0 && values.length > maxBatchSize) {
-    throw new InvalidOperationError3(
-      "insert",
-      `Batch size ${values.length} exceeds maxBatchSize ${maxBatchSize}`
-    );
+function deriveForeignKey(context, deriveFk = defaultFkDerivation, defaultPk = DEFAULT_PK_COLUMN) {
+  const fk = context.foreignKey ?? context.sourceFK;
+  if (fk) return fk;
+  if (!context.relationType) return void 0;
+  if (context.relationType === "belongsTo") {
+    return context.target ? deriveFk(context.target, defaultPk) : void 0;
   }
-  const batchThreshold = options?.batchThreshold ?? 50;
-  const useUnnest = values.length > 0 && (batchThreshold === 0 || values.length > batchThreshold);
-  const ast = useUnnest ? compileUnnestInsert(config, ctx, state) : compileInsert(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
+  return context.sourceTable ? deriveFk(context.sourceTable, defaultPk) : void 0;
+}
+function mapComparisonOperator(op3) {
+  const map = {
+    eq: "=",
+    neq: "!=",
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<=",
+    like: "LIKE",
+    ilike: "ILIKE",
+    isDistinctFrom: "IS DISTINCT FROM"
   };
-}
-function compileInsertFrom2(intent, _options, deps) {
-  const schemaName = deps.schemaName;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.source,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100
-  };
-  const state = createCompilerState();
-  const config = {
-    targetTable: intent.table,
-    sourceTable: intent.source,
-    ...intent.columns && { columns: [...intent.columns] },
-    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
-    ...intent.limit !== void 0 && { limit: intent.limit },
-    ...intent.returning && { returning: [...intent.returning] }
-  };
-  const ast = compileInsertFrom(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
-  };
-}
-function compileUpdate2(intent, _options, deps) {
-  const schemaName = deps.schemaName;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.table,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100
-  };
-  const state = createCompilerState();
-  const setColumns = Object.keys(intent.set ?? {});
-  const columnTypes = getColumnTypes(intent.table, setColumns, deps);
-  const config = {
-    table: intent.table,
-    set: Object.entries(intent.set ?? {}).map(([column, value]) => ({
-      column,
-      value
-    })),
-    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
-    ...intent.returning && { returning: [...intent.returning] },
-    ...columnTypes && { columnTypes }
-  };
-  const ast = compileUpdate(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
-  };
-}
-function compileBatchUpdate(intent, _options, deps) {
-  const schemaName = deps.schemaName;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.table,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100
-  };
-  const state = createCompilerState();
-  if (intent.updates.length === 0) {
-    throw new InvalidOperationError3(
-      "update",
-      "batchSet requires at least one row"
-    );
-  }
-  const allColumns = Object.keys(intent.updates[0]);
-  const matchColumns = [...intent.matchColumns];
-  for (const mc of matchColumns) {
-    if (!allColumns.includes(mc)) {
-      throw new InvalidOperationError3(
-        "update",
-        `Match column "${mc}" not found in update data. Each row must include the match column(s).`
-      );
-    }
-  }
-  const values = intent.updates.map((row) => allColumns.map((col) => row[col]));
-  validateBatchCardinality(allColumns, values);
-  const columnArrays = transposeToColumnArrays(allColumns, values);
-  const columnTypes = getColumnTypes(intent.table, allColumns, deps);
-  const scalarSet = intent.scalarSet ? Object.entries(intent.scalarSet).map(([column, value]) => ({
-    column,
-    value
-  })) : void 0;
-  let whereGuard;
-  if (intent.where) {
-    const whereCtx = {
-      rootTable: intent.table,
-      aliases: /* @__PURE__ */ new Map(),
-      paramState: state,
-      naming: deps.naming,
-      ...schemaName !== void 0 && { schemaName },
-      ...deps.model !== void 0 && { model: deps.model },
-      compileSubquery: (sqIntent, paramOffset) => buildSubqueryFromIntent(
-        sqIntent,
-        paramOffset,
-        deps.naming,
-        schemaName,
-        "rawExists"
-      )
-    };
-    whereGuard = compileWhereIntent(intent.where, whereCtx);
-  }
-  const config = {
-    table: intent.table,
-    matchColumns,
-    allColumns,
-    columnArrays,
-    ...scalarSet && { scalarSet },
-    ...intent.returning && { returning: [...intent.returning] },
-    ...columnTypes && { columnTypes },
-    ...whereGuard !== void 0 && { whereGuard }
-  };
-  const ast = compileUnnestUpdate(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
-  };
-}
-function compileDelete2(intent, options, deps) {
-  const schemaName = deps.schemaName;
-  const resolvedModel = options?.model ?? deps.model;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.table,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100,
-    ...resolvedModel !== void 0 && { model: resolvedModel }
-  };
-  const state = createCompilerState();
-  const resolvedWhere = intent.where ? resolveExistsIntent(intent.where, intent.table, deps) : void 0;
-  const config = {
-    table: intent.table,
-    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
-    ...intent.returning && { returning: [...intent.returning] }
-  };
-  const ast = compileDelete(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
-  };
-}
-function compileUpsert2(intent, options, deps) {
-  const schemaName = deps.schemaName;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.table,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100
-  };
-  const state = createCompilerState();
-  const firstRow = intent.values?.[0] ?? {};
-  const rawExprs = {};
-  const scalarSet = {};
-  if (intent.action.type === "doUpdate" && intent.action.set) {
-    for (const [key, val] of Object.entries(intent.action.set)) {
-      if (isSqlRaw2(val)) {
-        rawExprs[key] = val.sql;
-      } else {
-        scalarSet[key] = val;
-      }
-    }
-  }
-  const hasScalarSet = Object.keys(scalarSet).length > 0;
-  const mergedFirstRow = hasScalarSet ? { ...firstRow, ...scalarSet } : firstRow;
-  const columns = Object.keys(mergedFirstRow);
-  const values = (intent.values ?? []).map((row) => {
-    const mergedRow = hasScalarSet ? { ...row, ...scalarSet } : row;
-    return columns.map((col) => mergedRow[col]);
-  });
-  const conflictTarget = {};
-  if ("columns" in intent.onConflict) {
-    conflictTarget.columns = [...intent.onConflict.columns];
-  } else if ("constraint" in intent.onConflict) {
-    conflictTarget.constraint = intent.onConflict.constraint;
-  }
-  const conflictAction = intent.action.type === "doNothing" ? "nothing" : "update";
-  let updateColumns;
-  if (intent.action.type === "doUpdate") {
-    if (intent.action.set) {
-      updateColumns = Object.keys(intent.action.set);
-    } else {
-      const conflictCols = "columns" in intent.onConflict ? intent.onConflict.columns : [];
-      updateColumns = columns.filter((col) => !conflictCols.includes(col));
-    }
-  }
-  const columnTypes = getColumnTypes(intent.table, columns, deps);
-  const hasRawExprs = Object.keys(rawExprs).length > 0;
-  const config = {
-    table: intent.table,
-    columns,
-    values,
-    conflictTarget,
-    conflictAction,
-    ...updateColumns && { updateColumns },
-    ...intent.returning && { returning: [...intent.returning] },
-    ...columnTypes && { columnTypes },
-    ...hasRawExprs && { updateExpressions: rawExprs }
-  };
-  const maxBatchSize = options?.maxBatchSize;
-  if (maxBatchSize !== void 0 && values.length > maxBatchSize) {
-    throw new InvalidOperationError3(
-      "upsert",
-      `Batch size ${values.length} exceeds maxBatchSize ${maxBatchSize}`
-    );
-  }
-  const batchThreshold = options?.batchThreshold ?? 50;
-  const useUnnest = values.length > 0 && (batchThreshold === 0 || values.length > batchThreshold);
-  const ast = useUnnest ? compileUnnestUpsert(config, ctx, state) : compileUpsert(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
-  };
-}
-function compileUpsertFrom2(intent, options, deps) {
-  const schemaName = deps.schemaName;
-  const ctx = {
-    naming: deps.naming,
-    rootTable: intent.source,
-    ...schemaName !== void 0 && { schema: schemaName },
-    maxRecursiveDepth: 100
-  };
-  const state = createCompilerState();
-  let columns;
-  if (intent.columns) {
-    columns = [...intent.columns];
-  } else if (options?.model) {
-    const targetTable = options.model.getTable(intent.table);
-    if (targetTable) {
-      columns = targetTable.columns.map((c) => c.name);
-    }
-  }
-  const config = {
-    targetTable: intent.table,
-    sourceTable: intent.source,
-    conflictColumns: [...intent.conflictColumns],
-    ...columns && { columns },
-    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
-    ...intent.limit !== void 0 && { limit: intent.limit },
-    ...intent.returning && { returning: [...intent.returning] }
-  };
-  const ast = compileUpsertFrom(config, ctx, state);
-  const sql = deparseQuoted(ast);
-  return {
-    sql,
-    parameters: state.parameters
-  };
-}
-
-// src/adapter-compiler-select.ts
-init_assert_field();
-init_ast_helpers();
-init_compile_where();
-import { countDistinctRelationPathsByName } from "@dbsp/core";
-init_compiler_utils();
-init_types();
-init_intent_to_decisions();
-init_param_ref();
-
-// src/plan-decision-extractor.ts
-init_assert_field();
-init_intent_to_decisions();
-import { deriveRelationPathFromIntentPath } from "@dbsp/core";
-function findExistsIntents(where) {
-  if (!where || typeof where !== "object") return [];
-  const w = where;
-  if (w.kind === "exists" || w.kind === "notExists" || w.kind === "relationFilter") {
-    return [w];
-  }
-  const results = [];
-  if (w.conditions && Array.isArray(w.conditions)) {
-    for (const c of w.conditions) {
-      results.push(...findExistsIntents(c));
-    }
-  }
-  if (w.condition) {
-    results.push(...findExistsIntents(w.condition));
-  }
-  return results;
-}
-function resolveRelation(model, sourceTable, relationName) {
-  const rel = model.getRelation(`${sourceTable}.${relationName}`);
-  if (!rel) return void 0;
-  const foreignKey = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
-  const relationType = rel.type;
-  return { target: rel.target, foreignKey, relationType };
-}
-function resolveIncludeAlias(context) {
-  return context.relation ?? context.includeAlias;
-}
-function resolveIncludeByPath(includes, intentPath, relationName) {
-  if (!includes) return void 0;
-  if (intentPath) {
-    const indexPattern = /include\[(\d+)\]/g;
-    let current = includes;
-    let resolved;
-    let execResult = indexPattern.exec(intentPath);
-    while (execResult !== null) {
-      const idx = parseInt(execResult[1], 10);
-      const item = current[idx];
-      if (!item) break;
-      resolved = item;
-      current = item.include ?? [];
-      execResult = indexPattern.exec(intentPath);
-    }
-    if (resolved) return resolved;
-  }
-  return includes.find(
-    (i) => i.relation === relationName || i.via === relationName
-  );
-}
-function deriveForeignKey(context, deriveFk = defaultFkDerivation, defaultPk = DEFAULT_PK_COLUMN) {
-  const fk = context.foreignKey ?? context.sourceFK;
-  if (fk) return fk;
-  if (!context.relationType) return void 0;
-  if (context.relationType === "belongsTo") {
-    return context.target ? deriveFk(context.target, defaultPk) : void 0;
-  }
-  return context.sourceTable ? deriveFk(context.sourceTable, defaultPk) : void 0;
-}
-function mapComparisonOperator(op3) {
-  const map = {
-    eq: "=",
-    neq: "!=",
-    gt: ">",
-    gte: ">=",
-    lt: "<",
-    lte: "<=",
-    like: "LIKE",
-    ilike: "ILIKE",
-    isDistinctFrom: "IS DISTINCT FROM"
-  };
-  return map[op3] ?? "=";
+  return map[op3] ?? "=";
 }
 function convertWhereToDecisions(where, table) {
   if (!where || typeof where !== "object") return [];
@@ -15424,288 +15236,754 @@ function compileJoinIntents(joins, rootTable, schemaName, deps) {
       });
     }
   }
-  return results;
+  return results;
+}
+function stripJoinColumnsForAggregation(decisions, intent) {
+  const isAggregateOnly = intent.select && "type" in intent.select && intent.select.type === "aggregate" && !("fields" in intent.select && intent.select.fields);
+  const isDistinct = intent.distinct === true;
+  const hasGroupBy = intent.groupBy && intent.groupBy.length > 0;
+  const hasExplicitColumns = intent.select && "type" in intent.select && intent.select.type === "expressions";
+  if (isAggregateOnly || isDistinct || hasGroupBy || hasExplicitColumns) {
+    for (const d of decisions) {
+      if (d.type === "includeStrategy" && d.choice === "join") {
+        d.columns = [];
+      }
+    }
+  }
+}
+function buildRelationColumnsMap(decisions, includedRelations) {
+  const map = /* @__PURE__ */ new Map();
+  for (const d of decisions) {
+    if (!(d.type === "selectRelationColumn" && d.relation && d.column))
+      continue;
+    const col = d.column;
+    const alias = d.alias;
+    const fullRelation = d.relation;
+    const rootRelation = fullRelation.split(".")[0] ?? "";
+    if (!includedRelations.has(rootRelation)) continue;
+    const mapKey = fullRelation;
+    if (col === "*") {
+      map.set(mapKey, [{ col: "*" }]);
+      continue;
+    }
+    const existing = map.get(mapKey);
+    if (existing) {
+      if (existing.length === 1 && existing[0]?.col === "*") continue;
+      if (!existing.some((e) => e.col === col)) {
+        existing.push({ col, ...alias !== void 0 && { alias } });
+      }
+    } else {
+      map.set(mapKey, [{ col, ...alias !== void 0 && { alias } }]);
+    }
+  }
+  return map;
+}
+function injectAndValidateRelationColumns(enrichedUnifiedDecisions, relationColumnsMap, model) {
+  if (relationColumnsMap.size === 0) return;
+  for (const d of enrichedUnifiedDecisions) {
+    if (d.type === "includeStrategy" && d.relationName) {
+      const mapKey = d.relationPath ?? d.relationName;
+      const entries = mapKey ? relationColumnsMap.get(mapKey) : void 0;
+      if (entries) {
+        const mut = d;
+        mut.columns = entries.map((e) => e.col);
+        const aliasMap = {};
+        for (const { col, alias } of entries) {
+          if (alias) aliasMap[col] = alias;
+        }
+        if (Object.keys(aliasMap).length > 0) {
+          mut.columnAliases = aliasMap;
+        }
+      }
+    }
+  }
+  if (!model) return;
+  for (const d of enrichedUnifiedDecisions) {
+    if (d.type === "includeStrategy" && d.columns && d.targetTable && !(d.columns.length === 1 && d.columns[0] === "*")) {
+      const targetTable = model.getTable(d.targetTable);
+      if (targetTable) {
+        const validColumnNames = new Set(
+          targetTable.columns.map((c) => c.name)
+        );
+        const invalid = d.columns.filter(
+          (c) => !validColumnNames.has(c)
+        );
+        if (invalid.length > 0) {
+          throw new Error(
+            `Unknown column(s) ${invalid.map((c) => `'${c}'`).join(", ")} in relation '${d.relationName}' (table '${d.targetTable}'). Available: ${[...validColumnNames].join(", ")}`
+          );
+        }
+      }
+    }
+  }
+}
+function applyJoinHydrationPrefixes(decisions) {
+  const usages = [];
+  for (const d of decisions) {
+    if (d.type !== "includeStrategy" || d.choice !== "join" || !d.relationName) {
+      continue;
+    }
+    const relationName = d.relationName;
+    const relationPath = d.relationPath ?? relationName;
+    usages.push({ relationName, relationPath });
+  }
+  const pathCountsByRelation = countDistinctRelationPathsByName(usages);
+  for (const d of decisions) {
+    if (d.type !== "includeStrategy" || d.choice !== "join" || !d.relationName) {
+      continue;
+    }
+    const relationName = d.relationName;
+    const relationPath = d.relationPath ?? relationName;
+    const usesFullPath = (pathCountsByRelation.get(relationName) ?? 0) > 1;
+    d.hydrationPrefix = usesFullPath ? relationPath : relationName;
+  }
+}
+function enrichRangeDecisions(allDecisions, model, rootTable) {
+  if (!model) return;
+  for (let i = 0; i < allDecisions.length; i++) {
+    const d = allDecisions[i];
+    if (d && d.type === "where" && (d.operator === "contains" || d.operator === "containedBy" || d.operator === "overlaps")) {
+      const tableName = d.table || rootTable;
+      const table = model.getTable(tableName);
+      if (table) {
+        const col = table.columns.find((c) => c.name === d.column);
+        if (col?.type.endsWith("range")) {
+          allDecisions[i] = { ...d, dataType: col.type };
+        }
+      }
+    }
+  }
+}
+function buildSimplifiedPlanReport(plan, allDecisions, schemaName) {
+  const bvFromSource = plan.intent?.batchValuesSource;
+  const batchValuesFromFields = bvFromSource ? (() => {
+    const { rangeFunction, params } = buildBatchValuesRangeFn(
+      bvFromSource,
+      1
+    );
+    return {
+      batchValuesFromNode: rangeFunction,
+      batchValuesFromParams: params
+    };
+  })() : {};
+  return {
+    rootTable: plan.rootTable,
+    decisions: allDecisions,
+    ...schemaName ? { schema: schemaName } : {},
+    ...plan.intent?.existsWrap ? { existsWrap: true } : {},
+    ...plan.intent?.lock ? { lock: plan.intent.lock } : {},
+    ...batchValuesFromFields
+  };
+}
+function compileSelect(plan, options, deps) {
+  const schemaName = deps.schemaName;
+  const resolvedModelForCompiler = options?.model ?? deps.model;
+  const compilerOptions = {
+    naming: deps.naming,
+    ...schemaName && { schema: schemaName },
+    defaultPkColumnName: deps.defaultPk,
+    deriveFkColumnName: deps.deriveFk,
+    ...deps.bindingNames !== void 0 && {
+      bindingNames: deps.bindingNames
+    },
+    ...resolvedModelForCompiler != null && {
+      model: resolvedModelForCompiler
+    }
+  };
+  const execIntent = plan.executableIntent ?? plan.intent;
+  const planForCompilation = plan.executableIntent !== void 0 ? { ...plan, intent: plan.executableIntent } : plan;
+  let simplifiedPlan;
+  if (execIntent) {
+    let decisions = intentToDecisions(execIntent, plan.rootTable);
+    const resolvedModel = options?.model ?? deps.model;
+    if (resolvedModel) {
+      decisions = convertDottedFieldsToExists(
+        decisions,
+        plan.rootTable,
+        resolvedModel
+      );
+    }
+    enrichExistsDecisionsInPlace(
+      decisions,
+      planForCompilation,
+      options?.model ?? deps.model
+    );
+    const unifiedIncludeDecisions = extractAllIncludeDecisions(
+      planForCompilation,
+      deps.defaultPk,
+      deps.deriveFk
+    );
+    const coveredByPlanner = new Set(
+      unifiedIncludeDecisions.filter((d) => d.type === "includeStrategy").map((d) => d.relationName).filter(Boolean)
+    );
+    const synthesizedModel = options?.model ?? deps.model;
+    const synthesizedJoins = synthesizedModel ? synthesizeMissingJoinDecisions(
+      planForCompilation,
+      coveredByPlanner,
+      synthesizedModel,
+      deps.defaultPk,
+      deps.deriveFk
+    ) : [];
+    const allUnifiedIncludeDecisions = synthesizedJoins.length > 0 ? [...unifiedIncludeDecisions, ...synthesizedJoins] : unifiedIncludeDecisions;
+    const enrichedUnifiedDecisions = [
+      ...allUnifiedIncludeDecisions
+    ];
+    stripJoinColumnsForAggregation(enrichedUnifiedDecisions, execIntent);
+    applyJoinHydrationPrefixes(enrichedUnifiedDecisions);
+    const includedRelations = new Set(
+      enrichedUnifiedDecisions.filter((d) => d.type === "includeStrategy").map((d) => d.relationName).filter(Boolean)
+    );
+    if (includedRelations.size > 0) {
+      const relationColumnsMap = buildRelationColumnsMap(
+        decisions,
+        includedRelations
+      );
+      injectAndValidateRelationColumns(
+        enrichedUnifiedDecisions,
+        relationColumnsMap,
+        options?.model ?? deps.model
+      );
+    }
+    const deduplicatedDecisions = includedRelations.size > 0 ? decisions.filter((d) => {
+      if (d.type === "selectRelationColumn" && d.relation) {
+        const rel = d.relation;
+        const rootRelation = rel.split(".")[0] ?? rel;
+        if (includedRelations.has(rootRelation)) {
+          return false;
+        }
+      }
+      return true;
+    }) : decisions;
+    const joinIntentDecisions = execIntent?.joins && execIntent.joins.length > 0 ? compileJoinIntents(
+      execIntent.joins,
+      plan.rootTable,
+      schemaName,
+      deps
+    ) : [];
+    const allDecisions = [
+      ...deduplicatedDecisions,
+      ...enrichedUnifiedDecisions,
+      ...joinIntentDecisions
+    ];
+    const rangeModel = options?.model ?? deps.model;
+    enrichRangeDecisions(allDecisions, rangeModel, plan.rootTable);
+    simplifiedPlan = buildSimplifiedPlanReport(
+      planForCompilation,
+      allDecisions,
+      schemaName
+    );
+  } else {
+    simplifiedPlan = {
+      rootTable: plan.rootTable,
+      decisions: bridgeLegacyDecisions(plan.decisions),
+      ...schemaName ? { schema: schemaName } : {}
+    };
+  }
+  const result = compilePlan(simplifiedPlan, compilerOptions);
+  return {
+    sql: result.sql,
+    parameters: result.parameters
+  };
 }
-function stripJoinColumnsForAggregation(decisions, intent) {
-  const isAggregateOnly = intent.select && "type" in intent.select && intent.select.type === "aggregate" && !("fields" in intent.select && intent.select.fields);
-  const isDistinct = intent.distinct === true;
-  const hasGroupBy = intent.groupBy && intent.groupBy.length > 0;
-  const hasExplicitColumns = intent.select && "type" in intent.select && intent.select.type === "expressions";
-  if (isAggregateOnly || isDistinct || hasGroupBy || hasExplicitColumns) {
-    for (const d of decisions) {
-      if (d.type === "includeStrategy" && d.choice === "join") {
-        d.columns = [];
-      }
+function compileWithIncludes(plan, options, deps) {
+  const main = compileSelect(plan, options, deps);
+  const subqueryIncludes = [];
+  for (const d of plan.decisions) {
+    if (d.type !== "include-strategy" || d.choice !== "subquery") continue;
+    const ctx = d.context;
+    if (!ctx.target) continue;
+    const relationName = ctx.includeAlias ?? ctx.relation;
+    if (!relationName) continue;
+    const rawFk = deriveForeignKey(ctx, deps.deriveFk, deps.defaultPk) ?? deps.defaultPk;
+    const fk = Array.isArray(rawFk) ? rawFk[0] : rawFk;
+    const isBelongsTo = ctx.relationType === "belongsTo";
+    const sourceKey = isBelongsTo ? fk : "id";
+    const targetFk = isBelongsTo ? "id" : fk;
+    const includeIntent = plan.intent?.include?.find(
+      (i) => i.relation === relationName || i.relation === ctx.includeAlias
+    );
+    const entry = {
+      relationName,
+      targetTable: ctx.target,
+      foreignKey: targetFk,
+      sourceKey,
+      sourceTable: ctx.sourceTable ?? plan.rootTable
+    };
+    if (typeof ctx.relationType === "string") {
+      entry.relationType = ctx.relationType;
     }
-  }
-}
-function buildRelationColumnsMap(decisions, includedRelations) {
-  const map = /* @__PURE__ */ new Map();
-  for (const d of decisions) {
-    if (!(d.type === "selectRelationColumn" && d.relation && d.column))
-      continue;
-    const col = d.column;
-    const alias = d.alias;
-    const fullRelation = d.relation;
-    const rootRelation = fullRelation.split(".")[0] ?? "";
-    if (!includedRelations.has(rootRelation)) continue;
-    const mapKey = fullRelation;
-    if (col === "*") {
-      map.set(mapKey, [{ col: "*" }]);
-      continue;
+    if (includeIntent?.select != null) {
+      entry.select = includeIntent.select;
     }
-    const existing = map.get(mapKey);
-    if (existing) {
-      if (existing.length === 1 && existing[0]?.col === "*") continue;
-      if (!existing.some((e) => e.col === col)) {
-        existing.push({ col, ...alias !== void 0 && { alias } });
-      }
-    } else {
-      map.set(mapKey, [{ col, ...alias !== void 0 && { alias } }]);
+    if (includeIntent?.where != null) {
+      entry.where = includeIntent.where;
     }
+    subqueryIncludes.push(entry);
   }
-  return map;
+  return { main, subqueryIncludes };
 }
-function injectAndValidateRelationColumns(enrichedUnifiedDecisions, relationColumnsMap, model) {
-  if (relationColumnsMap.size === 0) return;
-  for (const d of enrichedUnifiedDecisions) {
-    if (d.type === "includeStrategy" && d.relationName) {
-      const mapKey = d.relationPath ?? d.relationName;
-      const entries = mapKey ? relationColumnsMap.get(mapKey) : void 0;
-      if (entries) {
-        const mut = d;
-        mut.columns = entries.map((e) => e.col);
-        const aliasMap = {};
-        for (const { col, alias } of entries) {
-          if (alias) aliasMap[col] = alias;
-        }
-        if (Object.keys(aliasMap).length > 0) {
-          mut.columnAliases = aliasMap;
-        }
-      }
-    }
+
+// src/adapter-compiler-mutations.ts
+init_binding_registry();
+init_compile_where();
+init_compiler_utils();
+init_handlers();
+function whereIntentAsDecision(where) {
+  return where;
+}
+function renumberSqlParams(sql, offset) {
+  if (offset === 0) return sql;
+  return sql.replace(/\$(\d+)/g, (_match, num) => {
+    return `$${Number.parseInt(num, 10) + offset}`;
+  });
+}
+function compileSourceQueryCte(operation, sourceName, sourceQuery, options, deps) {
+  const model = deps.model;
+  if (model === void 0) {
+    throw new Error(
+      `${operation} with sourceQuery requires a model to emit the source CTE for '${sourceName}'.`
+    );
   }
-  if (!model) return;
-  for (const d of enrichedUnifiedDecisions) {
-    if (d.type === "includeStrategy" && d.columns && d.targetTable && !(d.columns.length === 1 && d.columns[0] === "*")) {
-      const targetTable = model.getTable(d.targetTable);
-      if (targetTable) {
-        const validColumnNames = new Set(
-          targetTable.columns.map((c) => c.name)
-        );
-        const invalid = d.columns.filter(
-          (c) => !validColumnNames.has(c)
-        );
-        if (invalid.length > 0) {
-          throw new Error(
-            `Unknown column(s) ${invalid.map((c) => `'${c}'`).join(", ")} in relation '${d.relationName}' (table '${d.targetTable}'). Available: ${[...validColumnNames].join(", ")}`
-          );
-        }
-      }
+  const sourcePlan = planFn(sourceQuery, model, {
+    dialectCapabilities: POSTGRESQL_CAPABILITIES
+  });
+  return compileSelect(sourcePlan, options, deps);
+}
+function prependSourceCte(sql, parameters, sourceName, sourceCte, naming) {
+  if (sourceCte === void 0) {
+    return { sql, parameters };
+  }
+  const cteParamCount = sourceCte.parameters.length;
+  const sourceCteName = emittedBindName(sourceName, naming);
+  return {
+    sql: `WITH ${quoteIdent2(sourceCteName, "alias")} as (${sourceCte.sql}) ${renumberSqlParams(sql, cteParamCount)}`,
+    parameters: [...sourceCte.parameters, ...parameters]
+  };
+}
+function resolveExistsRelation(sourceTable, relation, model) {
+  if (!model) return { targetTable: relation };
+  const rel = model.getRelation(`${sourceTable}.${relation}`);
+  if (!rel) return { targetTable: relation };
+  const targetTable = rel.target;
+  if (rel.type === "belongsTo") {
+    const fk2 = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
+    return {
+      targetTable,
+      ...fk2 !== void 0 && { sourceColumn: fk2 },
+      targetColumn: "id"
+    };
+  }
+  const fk = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
+  return {
+    targetTable,
+    sourceColumn: rel.sourceKey ?? "id",
+    ...fk !== void 0 && { targetColumn: fk }
+  };
+}
+function resolveExistsIntent(where, sourceTable, deps) {
+  const w = where;
+  const kind = w.kind;
+  if (kind === "and" || kind === "or") {
+    const conditions = w.conditions;
+    if (!conditions) return where;
+    const enriched = conditions.map(
+      (c) => resolveExistsIntent(c, sourceTable, deps)
+    );
+    const changed = enriched.some((c, i) => c !== conditions[i]);
+    return changed ? { ...w, conditions: enriched } : where;
+  }
+  if (kind === "not") {
+    const condition = w.condition;
+    if (!condition) return where;
+    const enriched = resolveExistsIntent(condition, sourceTable, deps);
+    return enriched !== condition ? { ...w, condition: enriched } : where;
+  }
+  if (kind !== "exists" && kind !== "notExists") return where;
+  const relation = w.relation;
+  const resolved = resolveExistsRelation(sourceTable, relation, deps.model);
+  if (resolved.targetTable === relation && !resolved.sourceColumn) return where;
+  return {
+    ...w,
+    targetTable: resolved.targetTable,
+    ...resolved.sourceColumn !== void 0 && {
+      sourceColumn: resolved.sourceColumn
+    },
+    ...resolved.targetColumn !== void 0 && {
+      targetColumn: resolved.targetColumn
+    }
+  };
+}
+function getColumnTypes(tableName, columns, deps) {
+  if (!deps.model) return void 0;
+  const table = deps.model.getTable(tableName);
+  if (!table) return void 0;
+  let result;
+  for (const col of columns) {
+    const columnIR = table.columns.find((c) => c.name === col);
+    if (columnIR) {
+      result ??= {};
+      result[col] = columnIR.originalDbType ?? columnIR.type;
     }
   }
+  return result;
+}
+function compileUpsertActionWhere(where, table, state, deps, schemaName) {
+  const whereCtx = {
+    rootTable: table,
+    aliases: /* @__PURE__ */ new Map(),
+    paramState: state,
+    naming: deps.naming,
+    ...schemaName !== void 0 && { schemaName },
+    ...deps.bindingNames !== void 0 && { bindingNames: deps.bindingNames },
+    ...deps.model !== void 0 && { model: deps.model },
+    compileSubquery: (sqIntent, paramOffset) => buildSubqueryFromIntent(
+      sqIntent,
+      paramOffset,
+      deps.naming,
+      schemaName,
+      "rawExists",
+      deps.bindingNames
+    )
+  };
+  return compileWhereIntent(where, whereCtx);
+}
+function compileInsert2(intent, options, deps) {
+  const schemaName = deps.schemaName;
+  const ctx = {
+    naming: deps.naming,
+    rootTable: intent.table,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...deps.bindingNames !== void 0 && { bindingNames: deps.bindingNames },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  const firstRow = intent.values?.[0] ?? {};
+  const columns = Object.keys(firstRow);
+  const rows = intent.values ?? [];
+  const values = rows.map((row) => columns.map((col) => row[col]));
+  const columnTypes = getColumnTypes(intent.table, columns, deps);
+  const config = {
+    table: intent.table,
+    columns,
+    values,
+    ...intent.returning && { returning: [...intent.returning] },
+    ...columnTypes && { columnTypes }
+  };
+  const maxBatchSize = options?.maxBatchSize;
+  if (maxBatchSize !== void 0 && values.length > maxBatchSize) {
+    throw new InvalidOperationError3(
+      "insert",
+      `Batch size ${values.length} exceeds maxBatchSize ${maxBatchSize}`
+    );
+  }
+  const batchThreshold = options?.batchThreshold ?? 50;
+  const useUnnest = values.length > 0 && (batchThreshold === 0 || values.length > batchThreshold);
+  const ast = useUnnest ? compileUnnestInsert(config, ctx, state) : compileInsert(config, ctx, state);
+  const sql = deparseQuoted(ast);
+  return {
+    sql,
+    parameters: state.parameters
+  };
+}
+function compileInsertFrom2(intent, options, deps) {
+  const schemaName = deps.schemaName;
+  const sourceCte = intent.sourceQuery !== void 0 && !hasBindingName(deps.bindingNames, intent.source, deps.naming) ? compileSourceQueryCte(
+    "compileInsertFrom",
+    intent.source,
+    intent.sourceQuery,
+    options,
+    deps
+  ) : void 0;
+  const bindingNames = intent.sourceQuery !== void 0 ? withBindingName(deps.bindingNames, intent.source, deps.naming) : deps.bindingNames;
+  const ctx = {
+    naming: deps.naming,
+    rootTable: intent.source,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...bindingNames !== void 0 && { bindingNames },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  const config = {
+    targetTable: intent.table,
+    sourceTable: intent.source,
+    ...intent.columns && { columns: [...intent.columns] },
+    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
+    ...intent.limit !== void 0 && { limit: intent.limit },
+    ...intent.returning && { returning: [...intent.returning] }
+  };
+  const ast = compileInsertFrom(config, ctx, state);
+  const sql = deparseQuoted(ast);
+  return prependSourceCte(
+    sql,
+    state.parameters,
+    intent.source,
+    sourceCte,
+    deps.naming
+  );
 }
-function applyJoinHydrationPrefixes(decisions) {
-  const usages = [];
-  for (const d of decisions) {
-    if (d.type !== "includeStrategy" || d.choice !== "join" || !d.relationName) {
-      continue;
-    }
-    const relationName = d.relationName;
-    const relationPath = d.relationPath ?? relationName;
-    usages.push({ relationName, relationPath });
+function compileUpdate2(intent, options, deps) {
+  const schemaName = deps.schemaName;
+  const resolvedModel = options?.model ?? deps.model;
+  const ctx = {
+    naming: deps.naming,
+    rootTable: intent.table,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...deps.bindingNames !== void 0 && { bindingNames: deps.bindingNames },
+    ...resolvedModel !== void 0 && { model: resolvedModel },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  const setColumns = Object.keys(intent.set ?? {});
+  const columnTypes = getColumnTypes(intent.table, setColumns, deps);
+  const resolvedWhere = intent.where ? resolveExistsIntent(intent.where, intent.table, deps) : void 0;
+  const config = {
+    table: intent.table,
+    set: Object.entries(intent.set ?? {}).map(([column, value]) => ({
+      column,
+      value
+    })),
+    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
+    ...intent.returning && { returning: [...intent.returning] },
+    ...columnTypes && { columnTypes }
+  };
+  const ast = compileUpdate(config, ctx, state);
+  const sql = deparseQuoted(ast);
+  return {
+    sql,
+    parameters: state.parameters
+  };
+}
+function compileBatchUpdate(intent, _options, deps) {
+  const schemaName = deps.schemaName;
+  const ctx = {
+    naming: deps.naming,
+    rootTable: intent.table,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...deps.bindingNames !== void 0 && { bindingNames: deps.bindingNames },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  if (intent.updates.length === 0) {
+    throw new InvalidOperationError3(
+      "update",
+      "batchSet requires at least one row"
+    );
   }
-  const pathCountsByRelation = countDistinctRelationPathsByName(usages);
-  for (const d of decisions) {
-    if (d.type !== "includeStrategy" || d.choice !== "join" || !d.relationName) {
-      continue;
+  const allColumns = Object.keys(intent.updates[0]);
+  const matchColumns = [...intent.matchColumns];
+  for (const mc of matchColumns) {
+    if (!allColumns.includes(mc)) {
+      throw new InvalidOperationError3(
+        "update",
+        `Match column "${mc}" not found in update data. Each row must include the match column(s).`
+      );
     }
-    const relationName = d.relationName;
-    const relationPath = d.relationPath ?? relationName;
-    const usesFullPath = (pathCountsByRelation.get(relationName) ?? 0) > 1;
-    d.hydrationPrefix = usesFullPath ? relationPath : relationName;
   }
-}
-function enrichRangeDecisions(allDecisions, model, rootTable) {
-  if (!model) return;
-  for (let i = 0; i < allDecisions.length; i++) {
-    const d = allDecisions[i];
-    if (d && d.type === "where" && (d.operator === "contains" || d.operator === "containedBy" || d.operator === "overlaps")) {
-      const tableName = d.table || rootTable;
-      const table = model.getTable(tableName);
-      if (table) {
-        const col = table.columns.find((c) => c.name === d.column);
-        if (col?.type.endsWith("range")) {
-          allDecisions[i] = { ...d, dataType: col.type };
-        }
-      }
-    }
+  const values = intent.updates.map((row) => allColumns.map((col) => row[col]));
+  validateBatchCardinality(allColumns, values);
+  const columnArrays = transposeToColumnArrays(allColumns, values);
+  const columnTypes = getColumnTypes(intent.table, allColumns, deps);
+  const scalarSet = intent.scalarSet ? Object.entries(intent.scalarSet).map(([column, value]) => ({
+    column,
+    value
+  })) : void 0;
+  let whereGuard;
+  if (intent.where) {
+    const whereCtx = {
+      rootTable: intent.table,
+      aliases: /* @__PURE__ */ new Map(),
+      paramState: state,
+      naming: deps.naming,
+      ...schemaName !== void 0 && { schemaName },
+      ...deps.bindingNames !== void 0 && {
+        bindingNames: deps.bindingNames
+      },
+      ...deps.model !== void 0 && { model: deps.model },
+      compileSubquery: (sqIntent, paramOffset) => buildSubqueryFromIntent(
+        sqIntent,
+        paramOffset,
+        deps.naming,
+        schemaName,
+        "rawExists",
+        deps.bindingNames
+      )
+    };
+    whereGuard = compileWhereIntent(intent.where, whereCtx);
   }
+  const config = {
+    table: intent.table,
+    matchColumns,
+    allColumns,
+    columnArrays,
+    ...scalarSet && { scalarSet },
+    ...intent.returning && { returning: [...intent.returning] },
+    ...columnTypes && { columnTypes },
+    ...whereGuard !== void 0 && { whereGuard }
+  };
+  const ast = compileUnnestUpdate(config, ctx, state);
+  const sql = deparseQuoted(ast);
+  return {
+    sql,
+    parameters: state.parameters
+  };
 }
-function buildSimplifiedPlanReport(plan, allDecisions, schemaName) {
-  const bvFromSource = plan.intent?.batchValuesSource;
-  const batchValuesFromFields = bvFromSource ? (() => {
-    const { rangeFunction, params } = buildBatchValuesRangeFn(
-      bvFromSource,
-      1
-    );
-    return {
-      batchValuesFromNode: rangeFunction,
-      batchValuesFromParams: params
-    };
-  })() : {};
+function compileDelete2(intent, options, deps) {
+  const schemaName = deps.schemaName;
+  const resolvedModel = options?.model ?? deps.model;
+  const ctx = {
+    naming: deps.naming,
+    rootTable: intent.table,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...deps.bindingNames !== void 0 && { bindingNames: deps.bindingNames },
+    maxRecursiveDepth: 100,
+    ...resolvedModel !== void 0 && { model: resolvedModel }
+  };
+  const state = createCompilerState();
+  const resolvedWhere = intent.where ? resolveExistsIntent(intent.where, intent.table, deps) : void 0;
+  const config = {
+    table: intent.table,
+    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
+    ...intent.returning && { returning: [...intent.returning] }
+  };
+  const ast = compileDelete(config, ctx, state);
+  const sql = deparseQuoted(ast);
   return {
-    rootTable: plan.rootTable,
-    decisions: allDecisions,
-    ...schemaName ? { schema: schemaName } : {},
-    ...plan.intent?.existsWrap ? { existsWrap: true } : {},
-    ...plan.intent?.lock ? { lock: plan.intent.lock } : {},
-    ...batchValuesFromFields
+    sql,
+    parameters: state.parameters
   };
 }
-function compileSelect(plan, options, deps) {
+function compileUpsert2(intent, options, deps) {
   const schemaName = deps.schemaName;
-  const resolvedModelForCompiler = options?.model ?? deps.model;
-  const compilerOptions = {
+  const ctx = {
     naming: deps.naming,
-    ...schemaName && { schema: schemaName },
-    defaultPkColumnName: deps.defaultPk,
-    deriveFkColumnName: deps.deriveFk,
-    ...resolvedModelForCompiler != null && {
-      model: resolvedModelForCompiler
-    }
+    rootTable: intent.table,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...deps.bindingNames !== void 0 && { bindingNames: deps.bindingNames },
+    ...deps.model !== void 0 && { model: deps.model },
+    maxRecursiveDepth: 100
   };
-  const execIntent = plan.executableIntent ?? plan.intent;
-  const planForCompilation = plan.executableIntent !== void 0 ? { ...plan, intent: plan.executableIntent } : plan;
-  let simplifiedPlan;
-  if (execIntent) {
-    let decisions = intentToDecisions(execIntent, plan.rootTable);
-    const resolvedModel = options?.model ?? deps.model;
-    if (resolvedModel) {
-      decisions = convertDottedFieldsToExists(
-        decisions,
-        plan.rootTable,
-        resolvedModel
-      );
+  const state = createCompilerState();
+  const firstRow = intent.values?.[0] ?? {};
+  const rawExprs = {};
+  const scalarSet = {};
+  if (intent.action.type === "doUpdate" && intent.action.set) {
+    for (const [key, val] of Object.entries(intent.action.set)) {
+      if (isSqlRaw2(val)) {
+        rawExprs[key] = val.sql;
+      } else {
+        scalarSet[key] = val;
+      }
     }
-    enrichExistsDecisionsInPlace(
-      decisions,
-      planForCompilation,
-      options?.model ?? deps.model
-    );
-    const unifiedIncludeDecisions = extractAllIncludeDecisions(
-      planForCompilation,
-      deps.defaultPk,
-      deps.deriveFk
-    );
-    const coveredByPlanner = new Set(
-      unifiedIncludeDecisions.filter((d) => d.type === "includeStrategy").map((d) => d.relationName).filter(Boolean)
-    );
-    const synthesizedModel = options?.model ?? deps.model;
-    const synthesizedJoins = synthesizedModel ? synthesizeMissingJoinDecisions(
-      planForCompilation,
-      coveredByPlanner,
-      synthesizedModel,
-      deps.defaultPk,
-      deps.deriveFk
-    ) : [];
-    const allUnifiedIncludeDecisions = synthesizedJoins.length > 0 ? [...unifiedIncludeDecisions, ...synthesizedJoins] : unifiedIncludeDecisions;
-    const enrichedUnifiedDecisions = [
-      ...allUnifiedIncludeDecisions
-    ];
-    stripJoinColumnsForAggregation(enrichedUnifiedDecisions, execIntent);
-    applyJoinHydrationPrefixes(enrichedUnifiedDecisions);
-    const includedRelations = new Set(
-      enrichedUnifiedDecisions.filter((d) => d.type === "includeStrategy").map((d) => d.relationName).filter(Boolean)
-    );
-    if (includedRelations.size > 0) {
-      const relationColumnsMap = buildRelationColumnsMap(
-        decisions,
-        includedRelations
-      );
-      injectAndValidateRelationColumns(
-        enrichedUnifiedDecisions,
-        relationColumnsMap,
-        options?.model ?? deps.model
-      );
+  }
+  const hasScalarSet = Object.keys(scalarSet).length > 0;
+  const mergedFirstRow = hasScalarSet ? { ...firstRow, ...scalarSet } : firstRow;
+  const columns = Object.keys(mergedFirstRow);
+  const values = (intent.values ?? []).map((row) => {
+    const mergedRow = hasScalarSet ? { ...row, ...scalarSet } : row;
+    return columns.map((col) => mergedRow[col]);
+  });
+  const conflictTarget = {};
+  if ("columns" in intent.onConflict) {
+    conflictTarget.columns = [...intent.onConflict.columns];
+  } else if ("constraint" in intent.onConflict) {
+    conflictTarget.constraint = intent.onConflict.constraint;
+  }
+  const conflictAction = intent.action.type === "doNothing" ? "nothing" : "update";
+  let updateColumns;
+  if (intent.action.type === "doUpdate") {
+    if (intent.action.set) {
+      updateColumns = Object.keys(intent.action.set);
+    } else {
+      const conflictCols = "columns" in intent.onConflict ? intent.onConflict.columns : [];
+      updateColumns = columns.filter((col) => !conflictCols.includes(col));
     }
-    const deduplicatedDecisions = includedRelations.size > 0 ? decisions.filter((d) => {
-      if (d.type === "selectRelationColumn" && d.relation) {
-        const rel = d.relation;
-        const rootRelation = rel.split(".")[0] ?? rel;
-        if (includedRelations.has(rootRelation)) {
-          return false;
-        }
-      }
-      return true;
-    }) : decisions;
-    const joinIntentDecisions = execIntent?.joins && execIntent.joins.length > 0 ? compileJoinIntents(
-      execIntent.joins,
-      plan.rootTable,
-      schemaName,
-      deps
-    ) : [];
-    const allDecisions = [
-      ...deduplicatedDecisions,
-      ...enrichedUnifiedDecisions,
-      ...joinIntentDecisions
-    ];
-    const rangeModel = options?.model ?? deps.model;
-    enrichRangeDecisions(allDecisions, rangeModel, plan.rootTable);
-    simplifiedPlan = buildSimplifiedPlanReport(
-      planForCompilation,
-      allDecisions,
-      schemaName
+  }
+  const columnTypes = getColumnTypes(intent.table, columns, deps);
+  const hasRawExprs = Object.keys(rawExprs).length > 0;
+  const actionWhere = intent.action.type === "doUpdate" && intent.action.where ? intent.action.where : void 0;
+  const resolvedActionWhere = actionWhere ? resolveExistsIntent(actionWhere, intent.table, deps) : void 0;
+  const config = {
+    table: intent.table,
+    columns,
+    values,
+    conflictTarget,
+    conflictAction,
+    ...updateColumns && { updateColumns },
+    ...intent.returning && { returning: [...intent.returning] },
+    ...columnTypes && { columnTypes },
+    ...hasRawExprs && { updateExpressions: rawExprs },
+    ...resolvedActionWhere && {
+      actionWhereIntent: resolvedActionWhere,
+      compileActionWhere: (where, paramState) => compileUpsertActionWhere(
+        where,
+        intent.table,
+        paramState,
+        deps,
+        schemaName
+      )
+    }
+  };
+  const maxBatchSize = options?.maxBatchSize;
+  if (maxBatchSize !== void 0 && values.length > maxBatchSize) {
+    throw new InvalidOperationError3(
+      "upsert",
+      `Batch size ${values.length} exceeds maxBatchSize ${maxBatchSize}`
     );
-  } else {
-    simplifiedPlan = {
-      rootTable: plan.rootTable,
-      decisions: bridgeLegacyDecisions(plan.decisions),
-      ...schemaName ? { schema: schemaName } : {}
-    };
   }
-  const result = compilePlan(simplifiedPlan, compilerOptions);
+  const batchThreshold = options?.batchThreshold ?? 50;
+  const useUnnest = values.length > 0 && (batchThreshold === 0 || values.length > batchThreshold);
+  const ast = useUnnest ? compileUnnestUpsert(config, ctx, state) : compileUpsert(config, ctx, state);
+  const sql = deparseQuoted(ast);
   return {
-    sql: result.sql,
-    parameters: result.parameters
+    sql,
+    parameters: state.parameters
   };
 }
-function compileWithIncludes(plan, options, deps) {
-  const main = compileSelect(plan, options, deps);
-  const subqueryIncludes = [];
-  for (const d of plan.decisions) {
-    if (d.type !== "include-strategy" || d.choice !== "subquery") continue;
-    const ctx = d.context;
-    if (!ctx.target) continue;
-    const relationName = ctx.includeAlias ?? ctx.relation;
-    if (!relationName) continue;
-    const rawFk = deriveForeignKey(ctx, deps.deriveFk, deps.defaultPk) ?? deps.defaultPk;
-    const fk = Array.isArray(rawFk) ? rawFk[0] : rawFk;
-    const isBelongsTo = ctx.relationType === "belongsTo";
-    const sourceKey = isBelongsTo ? fk : "id";
-    const targetFk = isBelongsTo ? "id" : fk;
-    const includeIntent = plan.intent?.include?.find(
-      (i) => i.relation === relationName || i.relation === ctx.includeAlias
-    );
-    const entry = {
-      relationName,
-      targetTable: ctx.target,
-      foreignKey: targetFk,
-      sourceKey,
-      sourceTable: ctx.sourceTable ?? plan.rootTable
-    };
-    if (typeof ctx.relationType === "string") {
-      entry.relationType = ctx.relationType;
-    }
-    if (includeIntent?.select != null) {
-      entry.select = includeIntent.select;
-    }
-    if (includeIntent?.where != null) {
-      entry.where = includeIntent.where;
+function compileUpsertFrom2(intent, options, deps) {
+  const schemaName = deps.schemaName;
+  const sourceCte = intent.sourceQuery !== void 0 && !hasBindingName(deps.bindingNames, intent.source, deps.naming) ? compileSourceQueryCte(
+    "compileUpsertFrom",
+    intent.source,
+    intent.sourceQuery,
+    options,
+    deps
+  ) : void 0;
+  const bindingNames = intent.sourceQuery !== void 0 ? withBindingName(deps.bindingNames, intent.source, deps.naming) : deps.bindingNames;
+  const ctx = {
+    naming: deps.naming,
+    rootTable: intent.source,
+    ...schemaName !== void 0 && { schema: schemaName },
+    ...bindingNames !== void 0 && { bindingNames },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  let columns;
+  if (intent.columns) {
+    columns = [...intent.columns];
+  } else if (options?.model) {
+    const targetTable = options.model.getTable(intent.table);
+    if (targetTable) {
+      columns = targetTable.columns.map((c) => c.name);
     }
-    subqueryIncludes.push(entry);
   }
-  return { main, subqueryIncludes };
+  const config = {
+    targetTable: intent.table,
+    sourceTable: intent.source,
+    conflictColumns: [...intent.conflictColumns],
+    ...columns && { columns },
+    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
+    ...intent.limit !== void 0 && { limit: intent.limit },
+    ...intent.returning && { returning: [...intent.returning] }
+  };
+  const ast = compileUpsertFrom(config, ctx, state);
+  const sql = deparseQuoted(ast);
+  return prependSourceCte(
+    sql,
+    state.parameters,
+    intent.source,
+    sourceCte,
+    deps.naming
+  );
 }
 
 // src/adapter-compiler-recursive.ts
@@ -16794,6 +17072,7 @@ function buildRecursiveAnchorWhere(where, tableAlias, deps, state) {
 // src/pgsql-adapter.ts
 init_assert_field();
 init_ast_helpers();
+init_binding_registry();
 
 // src/ddl/index-operations.ts
 init_validate();
@@ -16960,9 +17239,9 @@ function compileLeafOrBranch(intent, compileFn) {
   const result = compileFn(intent);
   return { sql: result.sql, parameters: result.parameters };
 }
-function createLeafCompileFn(adapter, model, planFn2, options) {
+function createLeafCompileFn(adapter, model, planFn3, options) {
   return (query) => {
-    const planReport = planFn2(query, model, {
+    const planReport = planFn3(query, model, {
       dialectCapabilities: adapter.dialectCapabilities
     });
     return adapter.compile(planReport, { ...options, model });
@@ -17084,7 +17363,7 @@ function mapFetchDirection(direction) {
 
 // src/pgsql-adapter.ts
 init_validate();
-function renumberSqlParams(sql, offset) {
+function renumberSqlParams2(sql, offset) {
   if (offset === 0) return sql;
   return sql.replace(/\$(\d+)/g, (_match, num) => {
     return `$${Number.parseInt(num, 10) + offset}`;
@@ -17093,6 +17372,79 @@ function renumberSqlParams(sql, offset) {
 function isCompiledNqlQuery(input) {
   return !("intent" in input) && ("query" in input || "cteQuery" in input || "mutation" in input || "setOperation" in input || "bindings" in input || "mutationBindings" in input);
 }
+function formatGuardPathSegment(key) {
+  return /^[A-Za-z_$][\w$]*$/.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+}
+function findNqlBindingRefMarker(value, path, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  if (isNqlBindingRef2(value)) {
+    return {
+      ref: getNqlBindingRefName2(value),
+      path
+    };
+  }
+  if (seen.has(value)) {
+    return void 0;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const found = findNqlBindingRefMarker(value[i], `${path}[${i}]`, seen);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    const found = findNqlBindingRefMarker(
+      record[key],
+      `${path}${formatGuardPathSegment(key)}`,
+      seen
+    );
+    if (found) return found;
+  }
+  return void 0;
+}
+function guardCompiledQuery(query, context) {
+  const found = findNqlBindingRefMarker(query.parameters, "parameters");
+  if (found) {
+    throw new Error(
+      `NQL binding reference marker '${found.ref}' survived into emitted SQL parameters at ${found.path} while compiling ${context}. Binding references must resolve to CTE subqueries before SQL emission.`
+    );
+  }
+  return query;
+}
+function guardCompileResultWithIncludes(result, context) {
+  return {
+    ...result,
+    main: guardCompiledQuery(result.main, context)
+  };
+}
+function findPhysicalTableNameCollision(model, bindingName, naming) {
+  for (const [modelTableName, table] of model.tables) {
+    if (bindingName === table.name) return table.name;
+    if (bindingName === modelTableName) return table.name;
+    const emittedTableName = naming.toDatabase(table.name);
+    if (bindingName === emittedTableName) return emittedTableName;
+    const emittedModelTableName = naming.toDatabase(modelTableName);
+    if (bindingName === emittedModelTableName) return emittedModelTableName;
+  }
+  return void 0;
+}
+function findDuplicateEmittedNqlBindingName(bindingNames, naming) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const bindingName of bindingNames) {
+    const emittedName = emittedBindName(bindingName, naming);
+    const originalName = seen.get(emittedName);
+    if (originalName !== void 0 && originalName !== bindingName) {
+      return { originalName, duplicateName: bindingName, emittedName };
+    }
+    seen.set(emittedName, bindingName);
+  }
+  return void 0;
+}
 var PgsqlAdapter = class _PgsqlAdapter {
   pool;
   client;
@@ -17159,17 +17511,19 @@ var PgsqlAdapter = class _PgsqlAdapter {
       ...overrides
     };
   }
-  buildCompileDeps(options) {
+  buildCompileDeps(options, bindingNames) {
     if (options?.schemaName) {
       validateIdentifier(options.schemaName, "schema");
     }
+    const naming = options?.naming ?? this.naming;
     return {
-      naming: this.naming,
+      naming,
       // `||` (not `??`): empty string is treated as "no override" and falls back to this.schemaName (which may be a configured schema or undefined)
       schemaName: options?.schemaName || this.schemaName,
       model: options?.model ?? this.model,
       defaultPk: this.defaultPk,
-      deriveFk: this.deriveFk
+      deriveFk: this.deriveFk,
+      ...bindingNames !== void 0 && { bindingNames }
     };
   }
   requireNqlCompileModel(options) {
@@ -17181,7 +17535,24 @@ var PgsqlAdapter = class _PgsqlAdapter {
     }
     return model;
   }
-  compileNqlMutation(bundle, options) {
+  assertNqlBindingNamesDisjointFromTables(bindingNames, options) {
+    if (bindingNames === void 0 || bindingNames.size === 0) return;
+    const model = this.requireNqlCompileModel(options);
+    const naming = this.buildCompileDeps(options, bindingNames).naming;
+    for (const bindingName of bindingNames) {
+      const physicalTableName = findPhysicalTableNameCollision(
+        model,
+        bindingName,
+        naming
+      );
+      if (physicalTableName !== void 0) {
+        throw new Error(
+          `NQL binding '${bindingName}' collides with physical table name '${physicalTableName}'. NQL binding names must be disjoint from model table names.`
+        );
+      }
+    }
+  }
+  compileNqlMutation(bundle, options, bindingNames) {
     const mutation = bundle.mutation;
     if (mutation === void 0) {
       throw new Error("NQL bundle did not contain a mutation intent.");
@@ -17191,84 +17562,124 @@ var PgsqlAdapter = class _PgsqlAdapter {
         return compileInsert2(
           mutation,
           options,
-          this.buildCompileDeps(options)
+          this.buildCompileDeps(options, bindingNames)
         );
       case "insert_from":
         return compileInsertFrom2(
           mutation,
           options,
-          this.buildCompileDeps(options)
+          this.buildCompileDeps(options, bindingNames)
         );
       case "update":
         return compileUpdate2(
           mutation,
           options,
-          this.buildCompileDeps(options)
+          this.buildCompileDeps(options, bindingNames)
         );
       case "delete":
         return compileDelete2(
           mutation,
           options,
-          this.buildCompileDeps(options)
+          this.buildCompileDeps(options, bindingNames)
         );
       case "upsert":
         return compileUpsert2(
           mutation,
           options,
-          this.buildCompileDeps(options)
+          this.buildCompileDeps(options, bindingNames)
         );
       case "upsert_from":
         return compileUpsertFrom2(
           mutation,
           options,
-          this.buildCompileDeps(options)
+          this.buildCompileDeps(options, bindingNames)
         );
     }
     throw new Error(
       `Unsupported NQL mutation type: ${mutation.type}`
     );
   }
-  compileNqlBundleLeaf(bundle, options) {
+  compileNqlBundleLeaf(bundle, options, bindingNames) {
     if (bundle.query !== void 0) {
+      const naming = this.buildCompileDeps(options, bindingNames).naming;
+      if (hasBindingName(bindingNames, bundle.query.from, naming)) {
+        throw new Error(
+          `NQL binding '${bundle.query.from}' cannot be used as the final FROM source yet. Use the binding from a mutation source or WHERE IN predicate, or select from a real table.`
+        );
+      }
       const model = this.requireNqlCompileModel(options);
-      const planReport = planFn(bundle.query, model, {
+      const planReport = planFn2(bundle.query, model, {
         dialectCapabilities: this.dialectCapabilities
       });
-      return compileSelect(
-        planReport,
-        options,
-        this.buildCompileDeps(options)
+      return guardCompiledQuery(
+        compileSelect(
+          planReport,
+          options,
+          this.buildCompileDeps(options, bindingNames)
+        ),
+        "NQL query"
       );
     }
     if (bundle.cteQuery !== void 0) {
-      return compileCteQuery(
-        bundle.cteQuery,
-        options,
-        this.buildCompileDeps(options)
+      return guardCompiledQuery(
+        compileCteQuery(
+          bundle.cteQuery,
+          options,
+          this.buildCompileDeps(options, bindingNames)
+        ),
+        "NQL CTE query"
       );
     }
     if (bundle.setOperation !== void 0) {
       const model = this.requireNqlCompileModel(options);
-      return this.compileSetOperation(
-        bundle.setOperation,
-        model,
-        options
+      return guardCompiledQuery(
+        this.compileSetOperationWithBindings(
+          bundle.setOperation,
+          model,
+          options,
+          bindingNames
+        ),
+        "NQL set operation"
       );
     }
     if (bundle.mutation !== void 0) {
-      return this.compileNqlMutation(bundle, options);
+      return guardCompiledQuery(
+        this.compileNqlMutation(
+          bundle,
+          options,
+          bindingNames
+        ),
+        "NQL mutation"
+      );
     }
     throw new Error("NQL bundle did not contain a compilable intent.");
   }
   compileNqlBundle(bundle, options) {
     const ctes = [];
     const parameters = [];
+    const naming = this.buildCompileDeps(options).naming;
+    const duplicateEmittedBinding = bundle.bindings !== void 0 ? findDuplicateEmittedNqlBindingName(bundle.bindings.keys(), naming) : void 0;
+    if (duplicateEmittedBinding !== void 0) {
+      throw new Error(
+        `NQL bindings '${duplicateEmittedBinding.originalName}' and '${duplicateEmittedBinding.duplicateName}' emit to duplicate CTE name '${duplicateEmittedBinding.emittedName}'. NQL binding names must be unique after database naming.`
+      );
+    }
+    const bindingNames = bundle.bindings !== void 0 ? new Set(
+      [...bundle.bindings.keys()].map(
+        (name) => emittedBindName(name, naming)
+      )
+    ) : void 0;
+    this.assertNqlBindingNamesDisjointFromTables(bindingNames, options);
     for (const [name, queryIntent] of bundle.bindings ?? []) {
-      const cteName = quoteIdent2(name, "alias");
+      const cteName = quoteIdent2(emittedBindName(name, naming), "alias");
       const bindingBundle = bundle.mutationBindings?.has(name) ? { mutation: bundle.mutationBindings.get(name) } : { query: queryIntent };
-      const compiled2 = this.compileNqlBundleLeaf(bindingBundle, options);
+      const compiled2 = this.compileNqlBundleLeaf(
+        bindingBundle,
+        options,
+        bindingNames
+      );
       ctes.push(
-        `${cteName} as (${renumberSqlParams(compiled2.sql, parameters.length)})`
+        `${cteName} as (${renumberSqlParams2(compiled2.sql, parameters.length)})`
       );
       parameters.push(...compiled2.parameters);
     }
@@ -17281,14 +17692,21 @@ var PgsqlAdapter = class _PgsqlAdapter {
         setOperation: bundle.setOperation
       }
     };
-    const compiled = this.compileNqlBundleLeaf(leafBundle, options);
+    const compiled = this.compileNqlBundleLeaf(
+      leafBundle,
+      options,
+      bindingNames
+    );
     if (ctes.length === 0) {
-      return compiled;
+      return guardCompiledQuery(compiled, "NQL bundle");
     }
-    return {
-      sql: `WITH ${ctes.join(", ")} ${renumberSqlParams(compiled.sql, parameters.length)}`,
-      parameters: [...parameters, ...compiled.parameters]
-    };
+    return guardCompiledQuery(
+      {
+        sql: `WITH ${ctes.join(", ")} ${renumberSqlParams2(compiled.sql, parameters.length)}`,
+        parameters: [...parameters, ...compiled.parameters]
+      },
+      "NQL bundle"
+    );
   }
   /**
    * Returns the pool/client executor, or throws if in compile-only mode.
@@ -17308,7 +17726,7 @@ var PgsqlAdapter = class _PgsqlAdapter {
   }
   /** PostgreSQL dialect capabilities for planner strategy selection */
   get dialectCapabilities() {
-    return POSTGRESQL_CAPABILITIES;
+    return POSTGRESQL_CAPABILITIES2;
   }
   /**
    * DB column casing convention used by this adapter.
@@ -17332,16 +17750,18 @@ var PgsqlAdapter = class _PgsqlAdapter {
     if (isCompiledNqlQuery(plan)) {
       return this.compileNqlBundle(plan, options);
     }
-    return compileSelect(plan, options, this.buildCompileDeps(options));
+    return guardCompiledQuery(
+      compileSelect(plan, options, this.buildCompileDeps(options)),
+      "select plan"
+    );
   }
   /**
    * Compile a plan with includes, returning subquery include metadata (DX-033).
    */
   compileWithIncludes(plan, options) {
-    return compileWithIncludes(
-      plan,
-      options,
-      this.buildCompileDeps(options)
+    return guardCompileResultWithIncludes(
+      compileWithIncludes(plan, options, this.buildCompileDeps(options)),
+      "select plan with includes"
     );
   }
   /**
@@ -17354,11 +17774,14 @@ var PgsqlAdapter = class _PgsqlAdapter {
    * @returns Compiled query for fetching related records
    */
   compileSubqueryInclude(info, parentIds, options) {
-    return compileSubqueryInclude(
-      info,
-      parentIds,
-      options,
-      this.buildCompileDeps(options)
+    return guardCompiledQuery(
+      compileSubqueryInclude(
+        info,
+        parentIds,
+        options,
+        this.buildCompileDeps(options)
+      ),
+      "subquery include"
     );
   }
   /**
@@ -17402,7 +17825,10 @@ var PgsqlAdapter = class _PgsqlAdapter {
       targetList: [{ ResTarget: { val: node } }]
     });
     const sql = deparseQuoted(ast);
-    return { sql, parameters: state.parameters };
+    return guardCompiledQuery(
+      { sql, parameters: state.parameters },
+      "select expression"
+    );
   }
   /**
    * Compile an insert intent to executable SQL.
@@ -17412,24 +17838,29 @@ var PgsqlAdapter = class _PgsqlAdapter {
    * - rows > batchThreshold OR batchThreshold === 0: SELECT unnest($1::type[]),...
    */
   compileInsert(intent, options) {
-    return compileInsert2(intent, options, this.buildCompileDeps(options));
+    return guardCompiledQuery(
+      compileInsert2(intent, options, this.buildCompileDeps(options)),
+      "insert"
+    );
   }
   /**
    * Compile an insert-from intent to executable SQL (NQL-ALIGN).
    * INSERT INTO target (cols) SELECT cols FROM source WHERE ... LIMIT ... RETURNING ...
    */
   compileInsertFrom(intent, options) {
-    return compileInsertFrom2(
-      intent,
-      options,
-      this.buildCompileDeps(options)
+    return guardCompiledQuery(
+      compileInsertFrom2(intent, options, this.buildCompileDeps(options)),
+      "insert from"
     );
   }
   /**
    * Compile an update intent to executable SQL.
    */
   compileUpdate(intent, options) {
-    return compileUpdate2(intent, options, this.buildCompileDeps(options));
+    return guardCompiledQuery(
+      compileUpdate2(intent, options, this.buildCompileDeps(options)),
+      "update"
+    );
   }
   /**
    * Compile a batch update intent to executable SQL using unnest FROM strategy (BATCH-001).
@@ -17441,33 +17872,37 @@ var PgsqlAdapter = class _PgsqlAdapter {
    *   [RETURNING ...]
    */
   compileBatchUpdate(intent, options) {
-    return compileBatchUpdate(
-      intent,
-      options,
-      this.buildCompileDeps(options)
+    return guardCompiledQuery(
+      compileBatchUpdate(intent, options, this.buildCompileDeps(options)),
+      "batch update"
     );
   }
   /**
    * Compile a delete intent to executable SQL.
    */
   compileDelete(intent, options) {
-    return compileDelete2(intent, options, this.buildCompileDeps(options));
+    return guardCompiledQuery(
+      compileDelete2(intent, options, this.buildCompileDeps(options)),
+      "delete"
+    );
   }
   /**
    * Compile an upsert intent to executable SQL (DX-026).
    */
   compileUpsert(intent, options) {
-    return compileUpsert2(intent, options, this.buildCompileDeps(options));
+    return guardCompiledQuery(
+      compileUpsert2(intent, options, this.buildCompileDeps(options)),
+      "upsert"
+    );
   }
   /**
    * Compile an upsert-from intent to executable SQL (NQL-BIND).
    * INSERT INTO target SELECT ... FROM source ON CONFLICT (cols) DO UPDATE SET ...
    */
   compileUpsertFrom(intent, options) {
-    return compileUpsertFrom2(
-      intent,
-      options,
-      this.buildCompileDeps(options)
+    return guardCompiledQuery(
+      compileUpsertFrom2(intent, options, this.buildCompileDeps(options)),
+      "upsert from"
     );
   }
   /**
@@ -17475,11 +17910,14 @@ var PgsqlAdapter = class _PgsqlAdapter {
    * Supports adjacency-list and edge-table traversal modes.
    */
   compileRecursive(report, model, options) {
-    return compileRecursive(
-      report,
-      model,
-      options,
-      this.buildCompileDeps(options)
+    return guardCompiledQuery(
+      compileRecursive(
+        report,
+        model,
+        options,
+        this.buildCompileDeps(options)
+      ),
+      "recursive query"
     );
   }
   /**
@@ -17490,18 +17928,42 @@ var PgsqlAdapter = class _PgsqlAdapter {
    * to start after CTE params and prepend WITH clause.
    */
   compileCteQuery(intent, options) {
-    return compileCteQuery(intent, options, this.buildCompileDeps(options));
+    return guardCompiledQuery(
+      compileCteQuery(intent, options, this.buildCompileDeps(options)),
+      "CTE query"
+    );
   }
   /**
    * Compile a set operation (UNION / INTERSECT / EXCEPT) to SQL.
    */
   compileSetOperation(intent, model, options) {
-    const compileFn = createLeafCompileFn(this, model, planFn, options);
+    return guardCompiledQuery(
+      this.compileSetOperationWithBindings(intent, model, options),
+      "set operation"
+    );
+  }
+  compileSetOperationWithBindings(intent, model, options, bindingNames) {
+    const compileFn = createLeafCompileFn(
+      {
+        dialectCapabilities: this.dialectCapabilities,
+        compile: (planReport, leafOptions) => compileSelect(
+          planReport,
+          leafOptions,
+          this.buildCompileDeps(leafOptions, bindingNames)
+        )
+      },
+      model,
+      planFn2,
+      options
+    );
     const result = compileSetOperation(intent, compileFn);
-    return {
-      sql: result.sql,
-      parameters: result.parameters
-    };
+    return guardCompiledQuery(
+      {
+        sql: result.sql,
+        parameters: result.parameters
+      },
+      "set operation"
+    );
   }
   /**
    * Create a dump for observability.