@dbsp/adapter-pgsql 1.2.1 → 1.4.0

package/dist/index.js

@@ -949,6 +949,42 @@ var init_ast_helpers = __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/dialect-capabilities.ts
+function supportsDialectCapability(capabilities, flag) {
+  return capabilities?.[flag] !== false;
+}
+function assertDialectCapability(capabilities, flag, feature) {
+  if (!supportsDialectCapability(capabilities, flag)) {
+    throw new Error(`${feature} not supported by this adapter`);
+  }
+}
+var init_dialect_capabilities = __esm({
+  "src/dialect-capabilities.ts"() {
+    "use strict";
+  }
+});
+
 // src/param-ref.ts
 function validateParamRef(paramRef) {
   const errors = [];
@@ -2813,6 +2849,7 @@ var init_param_intent = __esm({
 });
 
 // src/handlers/where/utils.ts
+import { validateTypeName as validateTypeName3 } from "@dbsp/core";
 import { isFieldRef, isParamIntent as isParamIntent3 } from "@dbsp/types";
 function buildColumnRef(column, ctx) {
   if (column.includes(".")) {
@@ -2874,7 +2911,11 @@ function resolveColumnPgType(columnName, ctx) {
   if (!table) return void 0;
   const column = table.columns.find((c) => c.name === columnName);
   if (!column) return void 0;
-  if (column.originalDbType) return validateDbTypeName(column.originalDbType);
+  if (column.originalDbType) {
+    const typeName = column.originalDbType.trim();
+    validateTypeName3(typeName);
+    return typeName;
+  }
   return void 0;
 }
 var init_utils = __esm({
@@ -2883,7 +2924,6 @@ var init_utils = __esm({
     init_ast_helpers();
     init_param_intent();
     init_param_ref();
-    init_validate();
     init_types();
     init_param_intent();
   }
@@ -2915,6 +2955,7 @@ var init_any = __esm({
   "src/handlers/where/any.ts"() {
     "use strict";
     init_compiler_utils();
+    init_dialect_capabilities();
     init_param_intent();
     init_param_ref();
     init_types();
@@ -2922,6 +2963,11 @@ var init_any = __esm({
     anyHandler = {
       operators: [COLLECTION_OPERATORS.ANY],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsArrayType",
+          "ANY array operator is"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("ANY handler requires a column");
@@ -3117,6 +3163,9 @@ function buildCorrelation(sourceAlias, sourceColumn, targetAlias, targetColumn,
   const right = columnRef(targetColumn, targetAlias, void 0, ctx.naming);
   return eqExpr(left, right);
 }
+function schemaForExistsFromName(ctx, fromName) {
+  return schemaForFromName(ctx.schema, fromName, ctx.bindingNames, ctx.naming);
+}
 function buildExistsSubquery(decision, ctx, state, dispatch) {
   const relation = decision.relation;
   const targetTable = decision.targetTable ?? relation;
@@ -3160,7 +3209,7 @@ function buildExistsSubquery(decision, ctx, state, dispatch) {
   let fromNode = rangeVar(
     targetTable,
     targetAlias,
-    ctx.schema,
+    schemaForExistsFromName(ctx, targetTable),
     ctx.naming
   );
   const includeDecisions = decision.include;
@@ -3219,7 +3268,7 @@ function buildExistsSubquery(decision, ctx, state, dispatch) {
       const joinRangeVar = rangeVar(
         joinTargetTable,
         joinAlias,
-        ctx.schema,
+        schemaForExistsFromName(ctx, joinTargetTable),
         ctx.naming
       );
       fromNode = joinExpr(joinType, fromNode, joinRangeVar, joinQuals);
@@ -3245,6 +3294,7 @@ var init_exists = __esm({
     "use strict";
     init_assert_field();
     init_ast_helpers();
+    init_binding_registry();
     existsHandler = {
       operators: ["exists", "some"],
       compile(decision, ctx, state, dispatch) {
@@ -3315,6 +3365,21 @@ function createNotInExpr(columnNode, state, values, columnType) {
     }
   };
 }
+function createLiteralInListExpr(columnNode, state, values, negated) {
+  const paramRefs = values.map((value) => {
+    state.paramIndex++;
+    state.parameters.push(value);
+    return createParamRef(state.paramIndex);
+  });
+  return {
+    A_Expr: {
+      kind: "AEXPR_IN",
+      name: [{ String: { sval: negated ? "<>" : "=" } }],
+      lexpr: columnNode,
+      rexpr: { List: { items: paramRefs } }
+    }
+  };
+}
 function isWholeArrayParamList(value) {
   return value.length === 1 && isParamIntent4(value[0]) && Array.isArray(value[0].value);
 }
@@ -3330,6 +3395,7 @@ var init_in = __esm({
   "src/handlers/where/in.ts"() {
     "use strict";
     init_ast_helpers();
+    init_dialect_capabilities();
     init_param_intent();
     init_param_ref();
     init_types();
@@ -3358,7 +3424,11 @@ var init_in = __esm({
         }
         const columnNode = buildColumnRef(column, ctx);
         const columnType = resolveColumnPgType(column, ctx);
-        if (operator === COLLECTION_OPERATORS.NOT_IN || operator === "notIn") {
+        const isNotIn = operator === COLLECTION_OPERATORS.NOT_IN || operator === "notIn";
+        if (!supportsDialectCapability(ctx.dialectCapabilities, "supportsArrayType")) {
+          return createLiteralInListExpr(columnNode, state, values, isNotIn);
+        }
+        if (isNotIn) {
           return createNotInExpr(columnNode, state, values, columnType);
         }
         return createInExpr(columnNode, state, values, columnType);
@@ -3372,10 +3442,16 @@ var jsonContainsHandler, jsonExistsHandler, jsonComparisonHandler;
 var init_json = __esm({
   "src/handlers/where/json.ts"() {
     "use strict";
+    init_dialect_capabilities();
     init_utils();
     jsonContainsHandler = {
       operators: ["jsonContains", "jsonContainedBy"],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsJsonOperators",
+          "JSON operators are"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("JSON contains handler requires a column");
@@ -3396,6 +3472,11 @@ var init_json = __esm({
     jsonExistsHandler = {
       operators: ["jsonExists"],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsJsonOperators",
+          "JSON operators are"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("JSON exists handler requires a column");
@@ -3415,6 +3496,11 @@ var init_json = __esm({
     jsonComparisonHandler = {
       operators: ["jsonComparison"],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsJsonOperators",
+          "JSON operators are"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("JSON comparison handler requires a column");
@@ -3592,6 +3678,7 @@ var RANGE_OP_MAP, rangeHandler;
 var init_range = __esm({
   "src/handlers/where/range.ts"() {
     "use strict";
+    init_dialect_capabilities();
     init_param_intent();
     init_param_ref();
     init_types();
@@ -3604,6 +3691,11 @@ var init_range = __esm({
     rangeHandler = {
       operators: ["contains", "containedBy", "overlaps"],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsRangeTypes",
+          "Range operators are"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("Range handler requires a column");
@@ -3659,11 +3751,15 @@ function toHandlerContext(ctx) {
     currentAlias: ctx.currentAlias ?? ctx.rootTable,
     maxRecursiveDepth: 100,
     ...ctx.schemaName !== void 0 && { schema: ctx.schemaName },
+    ...ctx.dialectCapabilities !== void 0 && {
+      dialectCapabilities: ctx.dialectCapabilities
+    },
+    ...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, dialectCapabilities) {
   assertNoUnsupportedSubqueryModifiers(intent, use);
   if (intent.where && containsOuterRef(intent.where)) {
     throw new Error(
@@ -3708,9 +3804,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 = [];
@@ -3724,6 +3825,9 @@ function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, s
       aliases: /* @__PURE__ */ new Map(),
       paramState: innerState,
       naming,
+      ...schemaName !== void 0 && { schemaName },
+      ...dialectCapabilities !== void 0 && { dialectCapabilities },
+      ...bindingNames !== void 0 && { bindingNames },
       compileSubquery: (_nestedIntent, _nestedOffset) => {
         throw new Error(
           "buildSubqueryFromIntent: nested subquery not supported"
@@ -4101,6 +4205,7 @@ var init_compile_where = __esm({
     init_custom();
     init_handlers();
     init_assert_field();
+    init_binding_registry();
     init_types();
     init_utils();
     init_intent_to_decisions();
@@ -4145,7 +4250,9 @@ var init_raw_exists = __esm({
           state.paramIndex,
           ctx.naming,
           ctx.schema,
-          "rawExists"
+          "rawExists",
+          ctx.bindingNames,
+          ctx.dialectCapabilities
         );
         if (innerParams) {
           for (const p of innerParams) {
@@ -4381,7 +4488,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) {
@@ -4418,6 +4537,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();
   }
@@ -5941,11 +6061,17 @@ var init_json2 = __esm({
   "src/handlers/expression/json.ts"() {
     "use strict";
     init_ast_helpers();
+    init_dialect_capabilities();
     init_param_intent();
     init_utils();
     jsonExtractHandler = {
       types: ["jsonExtract"],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsJsonOperators",
+          "JSON operators are"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("JSON extract handler requires a column");
@@ -5973,6 +6099,11 @@ var init_json2 = __esm({
     jsonPathExtractHandler = {
       types: ["jsonPathExtract"],
       compile(decision, ctx, state) {
+        assertDialectCapability(
+          ctx.dialectCapabilities,
+          "supportsJsonOperators",
+          "JSON operators are"
+        );
         const column = decision.column;
         if (!column) {
           throw new Error("JSON path extract handler requires a column");
@@ -7044,12 +7175,14 @@ init_ast_helpers();
 // src/compiler.ts
 init_assert_field();
 init_ast_helpers();
+init_binding_registry();
 import { InvalidOperationError as InvalidOperationError2 } from "@dbsp/core";
 import {
   isParamIntent as isParamIntent6,
   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) {
@@ -8104,6 +8237,7 @@ function deparseQuoted(ast) {
 }
 
 // src/compiler.ts
+init_dialect_capabilities();
 init_case_value();
 init_custom();
 init_expression();
@@ -8336,6 +8470,8 @@ var PlanCompiler = class _PlanCompiler {
   defaultPk;
   deriveFk;
   model;
+  dialectCapabilities;
+  bindingNames;
   /** Mutable state shared with extracted condition/value compilation functions */
   state = {
     parameters: [],
@@ -8370,6 +8506,24 @@ var PlanCompiler = class _PlanCompiler {
     this.defaultPk = options.defaultPkColumnName ?? DEFAULT_PK_COLUMN;
     this.deriveFk = options.deriveFkColumnName ?? defaultFkDerivation;
     this.model = options.model ?? void 0;
+    this.dialectCapabilities = options.dialectCapabilities;
+    this.bindingNames = options.bindingNames;
+  }
+  childCompilerOptions(overrides = {}) {
+    return {
+      naming: this.naming,
+      ...this.schema !== void 0 && { schema: this.schema },
+      defaultPkColumnName: this.defaultPk,
+      deriveFkColumnName: this.deriveFk,
+      ...this.model !== void 0 && { model: this.model },
+      ...this.dialectCapabilities !== void 0 && {
+        dialectCapabilities: this.dialectCapabilities
+      },
+      ...this.bindingNames !== void 0 && {
+        bindingNames: this.bindingNames
+      },
+      ...overrides
+    };
   }
   /** Build immutable context for handler-based WHERE compilation */
   handlerCtx() {
@@ -8381,6 +8535,10 @@ var PlanCompiler = class _PlanCompiler {
       defaultPkColumnName: this.defaultPk,
       deriveFkColumnName: this.deriveFk,
       ...this.schema != null && { schema: this.schema },
+      ...this.dialectCapabilities != null && {
+        dialectCapabilities: this.dialectCapabilities
+      },
+      ...this.bindingNames != null && { bindingNames: this.bindingNames },
       ...this.model != null && { model: this.model }
     };
   }
@@ -8690,6 +8848,10 @@ var PlanCompiler = class _PlanCompiler {
       defaultPkColumnName: this.defaultPk,
       deriveFkColumnName: this.deriveFk,
       ...plan.schema ?? this.schema ? { schema: plan.schema ?? this.schema } : {},
+      ...this.dialectCapabilities != null && {
+        dialectCapabilities: this.dialectCapabilities
+      },
+      ...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)
@@ -8705,15 +8867,16 @@ var PlanCompiler = class _PlanCompiler {
       joins: []
     };
   }
+  schemaForRangeVar(plan, table) {
+    return schemaForFromName(
+      plan.schema ?? this.schema,
+      table,
+      this.bindingNames,
+      this.naming
+    );
+  }
   compileExpressionSubquery(query, paramOffset) {
-    const innerCompiler = new _PlanCompiler({
-      naming: this.naming,
-      ...this.schema !== void 0 && {
-        schema: this.schema
-      },
-      defaultPkColumnName: this.defaultPk,
-      deriveFkColumnName: this.deriveFk
-    });
+    const innerCompiler = new _PlanCompiler(this.childCompilerOptions());
     const innerPlan = {
       rootTable: query.from,
       decisions: intentToDecisions(query, query.from)
@@ -8731,14 +8894,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);
@@ -9053,24 +9216,7 @@ var PlanCompiler = class _PlanCompiler {
         const ctx = {
           ...this.createHandlerContext(plan, plan.rootTable),
           compileSubquery(query, paramOffset) {
-            const innerCompiler = new _PlanCompiler({
-              naming: outerThis.naming,
-              ...outerThis.schema !== void 0 && {
-                schema: outerThis.schema
-              },
-              defaultPkColumnName: outerThis.defaultPk,
-              deriveFkColumnName: outerThis.deriveFk
-            });
-            const innerPlan = {
-              rootTable: query.from,
-              decisions: intentToDecisions(query, query.from)
-            };
-            const innerResult = innerCompiler.compile(innerPlan);
-            const renumbered = renumberParamRefsInAst(
-              innerResult.ast,
-              paramOffset
-            );
-            return { ast: renumbered, parameters: innerResult.parameters };
+            return outerThis.compileExpressionSubquery(query, paramOffset);
           }
         };
         const state = this.createHandlerState();
@@ -9256,13 +9402,13 @@ var PlanCompiler = class _PlanCompiler {
       const targetRV = rangeVar(
         pj.table,
         pj.alias,
-        plan.schema ?? this.schema,
+        this.schemaForRangeVar(plan, pj.table),
         this.naming
       );
       const base = from.length > 0 ? from[0] : rangeVar(
         plan.rootTable,
         void 0,
-        plan.schema ?? this.schema,
+        this.schemaForRangeVar(plan, plan.rootTable),
         this.naming
       );
       from[0] = pj.type === "LEFT JOIN" ? leftJoin(base, targetRV, pj.on) : innerJoin(base, targetRV, pj.on);
@@ -9271,7 +9417,7 @@ var PlanCompiler = class _PlanCompiler {
       const base = from.length > 0 ? from[0] : rangeVar(
         plan.rootTable,
         void 0,
-        plan.schema ?? this.schema,
+        this.schemaForRangeVar(plan, plan.rootTable),
         this.naming
       );
       const joinExpr2 = rawJoin;
@@ -9296,7 +9442,7 @@ var PlanCompiler = class _PlanCompiler {
       plan.batchValuesFromNode ? plan.batchValuesFromNode : rangeVar(
         plan.rootTable,
         void 0,
-        plan.schema ?? this.schema,
+        this.schemaForRangeVar(plan, plan.rootTable),
         this.naming
       )
     ];
@@ -9390,19 +9536,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.lastIndexOf(".");
-    if (gbDot !== -1) {
-      const relation = gbCol.slice(0, gbDot);
-      const alias = this.resolvedJoinAliases().get(relation) ?? relation;
-      return columnRef(gbCol.slice(gbDot + 1), alias, 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.
@@ -9427,6 +9589,18 @@ var PlanCompiler = class _PlanCompiler {
       options.withClause = { ctes: this.pendingCtes, recursive: false };
     }
     if (plan.lock) {
+      assertDialectCapability(
+        this.dialectCapabilities,
+        "supportsRowLevelLocks",
+        "Row-level locks are"
+      );
+      if (plan.lock.waitPolicy !== "block") {
+        assertDialectCapability(
+          this.dialectCapabilities,
+          "supportsLockWaitPolicies",
+          "Lock wait policies are"
+        );
+      }
       const mapped = mapLockToAst(plan.lock);
       const hasJoins = this.rawJoins.length > 0;
       options.lockingClause = {
@@ -9436,7 +9610,7 @@ var PlanCompiler = class _PlanCompiler {
             rangeVar(
               plan.rootTable,
               void 0,
-              plan.schema ?? this.schema,
+              this.schemaForRangeVar(plan, plan.rootTable),
               this.naming
             )
           ]
@@ -9539,7 +9713,7 @@ 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;
@@ -9816,13 +9990,13 @@ var PlanCompiler = class _PlanCompiler {
     const baseTable = larg ?? rangeVar(
       plan.rootTable,
       void 0,
-      plan.schema ?? this.schema,
+      this.schemaForRangeVar(plan, plan.rootTable),
       this.naming
     );
     const targetTable = rangeVar(
       decision.targetTable ?? "",
       decision.alias,
-      plan.schema ?? this.schema,
+      this.schemaForRangeVar(plan, decision.targetTable ?? ""),
       this.naming
     );
     const onCondition = eqExpr(
@@ -13139,6 +13313,7 @@ function matchGlob(pattern, value) {
 
 // src/mutations/mutation-compiler.ts
 init_ast_helpers();
+init_binding_registry();
 init_compiler_utils();
 init_handlers();
 init_param_intent();
@@ -13364,12 +13539,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)
       )
     );
@@ -13409,8 +13590,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: {
@@ -13439,12 +13620,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)
       )
     );
@@ -13484,8 +13671,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: {
@@ -13630,6 +13817,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;
@@ -13643,18 +13852,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 = {
@@ -13700,10 +13903,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) {
@@ -13841,7 +14046,12 @@ 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,
+  validateTypeName as validateTypeName4
+} from "@dbsp/core";
+import { getNqlBindingRefName as getNqlBindingRefName2, isNqlBindingRef as isNqlBindingRef2 } from "@dbsp/types/internal";
 
 // src/adapter-compiler-includes.ts
 init_ast_helpers();
@@ -14027,426 +14237,75 @@ 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_binding_registry();
 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;
-}
-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}`
-    );
-  }
-  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 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
-  );
+  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;
@@ -14707,1070 +14566,1599 @@ function enrichExistsStubsInConditions(conditions, sourceTable, model) {
           }
           hopCheckSource = hopRel.target;
         }
-        const mode = d.operator === "notExists" ? "none" : d.operator === "every" ? "every" : "some";
-        const isEvery = mode === "every";
-        const outerOperator = d.operator === "notExists" || mode === "none" || isEvery ? "notExists" : "exists";
-        const finalTarget = hopCheckSource;
-        let rawInnerConditions;
-        if (rawWhere) {
-          const c = convertWhereToDecisions(rawWhere, finalTarget);
+        const mode = d.operator === "notExists" ? "none" : d.operator === "every" ? "every" : "some";
+        const isEvery = mode === "every";
+        const outerOperator = d.operator === "notExists" || mode === "none" || isEvery ? "notExists" : "exists";
+        const finalTarget = hopCheckSource;
+        let rawInnerConditions;
+        if (rawWhere) {
+          const c = convertWhereToDecisions(rawWhere, finalTarget);
+          if (c.length > 0) {
+            enrichExistsStubsInConditions(c, finalTarget, model);
+            rawInnerConditions = c;
+          }
+        }
+        if (isEvery && !rawInnerConditions) {
+          const firstHop = hops[0];
+          const firstRel = model.getRelation(`${sourceTable}.${firstHop}`);
+          conditions[i] = {
+            type: "where",
+            operator: "every",
+            targetTable: firstRel?.target ?? firstHop,
+            sourceTable
+          };
+          continue;
+        }
+        const innerConditions = isEvery && rawInnerConditions ? [
+          {
+            type: "logical",
+            operator: "not",
+            conditions: rawInnerConditions
+          }
+        ] : rawInnerConditions;
+        const enriched = buildMultiHopExistsChain(
+          hops,
+          sourceTable,
+          outerOperator,
+          innerConditions,
+          model
+        );
+        conditions[i] = enriched;
+      } else {
+        const relation = hops[0];
+        const rel = model.getRelation(`${sourceTable}.${relation}`);
+        if (!rel) {
+          throw new Error(
+            `exists('${relation}'): no relation '${relation}' is declared on table '${sourceTable}'. Use rawExists(subquery(...)) for an EXISTS over an undeclared or uncorrelated subquery.`
+          );
+        }
+        const foreignKey = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
+        const relationType = rel.type === "belongsTo" ? "belongsTo" : rel.type === "hasMany" || rel.type === "hasOne" ? rel.type : void 0;
+        const parentKey = relationType === "belongsTo" ? rel.targetKey : rel.sourceKey;
+        const targetTable = rel.target;
+        let innerConditions;
+        if (rawWhere) {
+          const c = convertWhereToDecisions(rawWhere, targetTable);
+          if (c.length > 0) innerConditions = c;
+        }
+        const includeDecisions = rawInclude ? Object.entries(rawInclude).map(([rel2, opts]) => ({
+          type: "existsInclude",
+          relation: rel2,
+          joinType: opts.join ?? "inner"
+        })) : void 0;
+        const enriched = {
+          type: "where",
+          operator: d.operator,
+          targetTable,
+          sourceTable,
+          ...foreignKey ? { foreignKey } : {},
+          ...relationType ? { relationType } : {},
+          ...parentKey ? { parentKey } : {},
+          ...innerConditions ? { conditions: innerConditions } : {},
+          ...includeDecisions ? { include: includeDecisions } : {}
+        };
+        conditions[i] = enriched;
+        if (innerConditions && innerConditions.length > 0) {
+          enrichExistsStubsInConditions(innerConditions, targetTable, model);
+        }
+      }
+    } else if ((d.type === "whereAnd" || d.type === "whereOr" || d.type === "whereNot") && d.conditions) {
+      enrichExistsStubsInConditions(
+        d.conditions,
+        sourceTable,
+        model
+      );
+    }
+  }
+}
+function buildEnrichedExistsDecision(d, matchingIntent, rootTable, model) {
+  const context = d.context;
+  const targetTable = context.target;
+  let conditions;
+  if (matchingIntent?.where) {
+    const nestedDecisions = convertWhereToDecisions(
+      matchingIntent.where,
+      targetTable
+    );
+    if (nestedDecisions.length > 0) {
+      conditions = nestedDecisions;
+      if (model) {
+        enrichExistsStubsInConditions(conditions, targetTable, model);
+      }
+    }
+  }
+  const sourceTableForRelation = context.sourceTable || rootTable;
+  const relIR = model && context.relation ? model.getRelation(
+    `${sourceTableForRelation}.${context.relation}`
+  ) : void 0;
+  const foreignKey = relIR ? typeof relIR.foreignKey === "string" ? relIR.foreignKey : relIR.foreignKey?.[0] : void 0;
+  const relationType = relIR?.type === "belongsTo" ? "belongsTo" : relIR?.type === "hasMany" || relIR?.type === "hasOne" ? relIR.type : void 0;
+  const parentKey = relationType === "belongsTo" ? relIR?.targetKey : relIR?.sourceKey;
+  let operator = "exists";
+  if (matchingIntent?.kind === "notExists") {
+    operator = "notExists";
+  } else if (matchingIntent?.kind === "relationFilter") {
+    const mode = matchingIntent.mode ?? "some";
+    if (mode === "none") operator = "notExists";
+    else if (mode === "every") operator = "every";
+  }
+  const includeIntent = matchingIntent?.include;
+  const includeDecisions = includeIntent ? Object.entries(includeIntent).map(([rel, opts]) => ({
+    type: "existsInclude",
+    relation: rel,
+    joinType: opts.join ?? "inner"
+  })) : void 0;
+  const relationName = context.relation;
+  return {
+    type: "where",
+    operator,
+    targetTable,
+    // sourceTable: the table this EXISTS is resolved FROM (the relation's source).
+    // Required by propagateExistsConditions's (sourceTable, relationName) identity
+    // guard — without it the guard is a no-op and cross-source propagation can occur
+    // when two relations share a name but originate from different tables.
+    sourceTable: sourceTableForRelation,
+    ...foreignKey ? { foreignKey } : {},
+    // relationType is required so deriveFkColumns (called by mapToHandlerDecision) can
+    // set sourceColumn/targetColumn in the correct direction for the EXISTS correlation.
+    ...relationType ? { relationType } : {},
+    // parentKey provides the explicit PK override for non-default PK columns.
+    ...parentKey ? { parentKey } : {},
+    ...conditions ? { conditions } : {},
+    ...d.choice === "join" ? { choice: "join" } : {},
+    ...relationName ? { relationName } : {},
+    ...includeDecisions ? { include: includeDecisions } : {}
+  };
+}
+function collectNestedExistsTargets(where, insideExists, sourceTable, model, out) {
+  if (!where || typeof where !== "object") return;
+  const w = where;
+  if (w.kind === "exists" || w.kind === "notExists" || w.kind === "relationFilter") {
+    if (insideExists) {
+      const rawRelation = w.relation;
+      const hops = Array.isArray(rawRelation) ? rawRelation : typeof rawRelation === "string" ? [rawRelation] : [];
+      if (hops.length === 1) {
+        const singleHop = hops[0] ?? "";
+        const rel = model.getRelation(`${sourceTable}.${singleHop}`);
+        const resolvedTarget = rel ? rel.target : singleHop;
+        out.add(`${sourceTable}:${resolvedTarget}`);
+      } else if (hops.length > 1) {
+        let penultimate = sourceTable;
+        for (let hi = 0; hi < hops.length - 1; hi++) {
+          const hr = model.getRelation(`${penultimate}.${hops[hi] ?? ""}`);
+          penultimate = hr ? hr.target : hops[hi] ?? penultimate;
+        }
+        out.add(`${penultimate}:${hops.join(".")}`);
+        const lastHop = hops[hops.length - 1] ?? "";
+        const lastRel = model.getRelation(`${penultimate}.${lastHop}`);
+        const finalTarget = lastRel ? lastRel.target : lastHop;
+        out.add(`${penultimate}:${finalTarget}`);
+      }
+      let nextSource = sourceTable;
+      if (hops.length >= 1) {
+        let cur = sourceTable;
+        for (const hop of hops) {
+          const rel = model.getRelation(`${cur}.${hop}`);
+          cur = rel ? rel.target : hop;
+        }
+        nextSource = cur;
+      }
+      if (w.where) {
+        collectNestedExistsTargets(w.where, true, nextSource, model, out);
+      }
+    } else {
+      const rawRelation = w.relation;
+      const hops = Array.isArray(rawRelation) ? rawRelation : typeof rawRelation === "string" ? [rawRelation] : [];
+      let nextSource = sourceTable;
+      if (hops.length >= 1) {
+        let cur = sourceTable;
+        for (const hop of hops) {
+          const rel = model.getRelation(`${cur}.${hop}`);
+          cur = rel ? rel.target : hop;
+        }
+        nextSource = cur;
+      }
+      if (w.where) {
+        collectNestedExistsTargets(w.where, true, nextSource, model, out);
+      }
+    }
+    return;
+  }
+  if (w.conditions && Array.isArray(w.conditions)) {
+    for (const c of w.conditions) {
+      collectNestedExistsTargets(c, insideExists, sourceTable, model, out);
+    }
+  }
+  if (w.condition) {
+    collectNestedExistsTargets(
+      w.condition,
+      insideExists,
+      sourceTable,
+      model,
+      out
+    );
+  }
+}
+function collectExistsStubs(decisions, out) {
+  decisions.forEach((d, i) => {
+    if (!d) return;
+    if (d.type === "where" && (d.operator === "exists" || d.operator === "notExists" || d.operator === "every")) {
+      if (d.relationName) return;
+      out.push({ decision: d, container: decisions, index: i });
+    } else if ((d.type === "whereAnd" || d.type === "whereOr" || d.type === "whereNot") && d.conditions) {
+      collectExistsStubs(d.conditions, out);
+    }
+  });
+}
+function normalizeStubRelation(targetTable) {
+  if (Array.isArray(targetTable) && targetTable.length > 0)
+    return targetTable[targetTable.length - 1];
+  if (typeof targetTable === "string") return targetTable;
+  return void 0;
+}
+function normalizeStubRelationPath(targetTable) {
+  if (Array.isArray(targetTable) && targetTable.length > 0)
+    return targetTable.join(".");
+  if (typeof targetTable === "string") return targetTable;
+  return void 0;
+}
+function enrichExistsDecisionsInPlace(decisions, plan, model) {
+  const stubs = [];
+  collectExistsStubs(decisions, stubs);
+  const nestedExistsTargets = /* @__PURE__ */ new Set();
+  if (plan.intent?.where && model) {
+    collectNestedExistsTargets(
+      plan.intent.where,
+      false,
+      plan.rootTable,
+      model,
+      nestedExistsTargets
+    );
+  }
+  const filterDecisions = plan.decisions.filter(
+    (d) => d.type === "filter-strategy" && (d.choice === "exists" || d.choice === "notExists" || d.choice === "join")
+  );
+  const placedDecisions = [];
+  const consumedStubIndices = /* @__PURE__ */ new Set();
+  if (filterDecisions.length > 0) {
+    const existsIntents = plan.intent?.where ? findExistsIntents(plan.intent.where) : [];
+    for (const d of filterDecisions) {
+      const context = d.context;
+      if (!context.target) continue;
+      const contextRelationPath = context.relationPath;
+      const contextSourceTableForIntent = context.sourceTable;
+      const isNestedRelation = contextSourceTableForIntent !== void 0 && contextSourceTableForIntent !== plan.rootTable && !contextRelationPath;
+      const matchIdx = isNestedRelation ? -1 : existsIntents.findIndex((i) => {
+        if (contextRelationPath) {
+          const intentPath = Array.isArray(i.relation) ? i.relation.join(".") : typeof i.relation === "string" ? i.relation : void 0;
+          return intentPath === contextRelationPath;
+        }
+        const rel = Array.isArray(i.relation) ? i.relation.length > 0 ? i.relation[i.relation.length - 1] : void 0 : typeof i.relation === "string" ? i.relation : void 0;
+        return rel === context.relation || rel === context.target || rel === context.includeAlias;
+      });
+      const matchingIntent = matchIdx >= 0 ? existsIntents[matchIdx] : void 0;
+      if (matchIdx >= 0) existsIntents.splice(matchIdx, 1);
+      const isMultiHop = matchingIntent && Array.isArray(matchingIntent.relation) && matchingIntent.relation.length > 1 && model;
+      let enriched;
+      if (isMultiHop && matchingIntent && model) {
+        const mode = matchingIntent.mode ?? "some";
+        const isEvery = matchingIntent.kind !== "notExists" && mode === "every";
+        const outerOperator = matchingIntent.kind === "notExists" || mode === "none" || isEvery ? "notExists" : "exists";
+        const lastHopTarget = context.target;
+        const rawInnerConditions = matchingIntent.where ? (() => {
+          const c = convertWhereToDecisions(
+            matchingIntent.where,
+            lastHopTarget
+          );
           if (c.length > 0) {
-            enrichExistsStubsInConditions(c, finalTarget, model);
-            rawInnerConditions = c;
+            enrichExistsStubsInConditions(c, lastHopTarget, model);
           }
-        }
+          return c.length > 0 ? c : void 0;
+        })() : void 0;
         if (isEvery && !rawInnerConditions) {
-          const firstHop = hops[0];
-          const firstRel = model.getRelation(`${sourceTable}.${firstHop}`);
-          conditions[i] = {
-            type: "where",
-            operator: "every",
-            targetTable: firstRel?.target ?? firstHop,
-            sourceTable
-          };
-          continue;
+          enriched = buildEnrichedExistsDecision(
+            d,
+            matchingIntent,
+            plan.rootTable,
+            model
+          );
+        } else {
+          const innerConditions = isEvery && rawInnerConditions ? [
+            {
+              type: "logical",
+              operator: "not",
+              conditions: rawInnerConditions
+            }
+          ] : rawInnerConditions;
+          enriched = buildMultiHopExistsChain(
+            matchingIntent.relation,
+            plan.rootTable,
+            outerOperator,
+            innerConditions,
+            model
+          );
         }
-        const innerConditions = isEvery && rawInnerConditions ? [
-          {
-            type: "logical",
-            operator: "not",
-            conditions: rawInnerConditions
-          }
-        ] : rawInnerConditions;
-        const enriched = buildMultiHopExistsChain(
-          hops,
-          sourceTable,
-          outerOperator,
-          innerConditions,
+      } else {
+        enriched = buildEnrichedExistsDecision(
+          d,
+          matchingIntent,
+          plan.rootTable,
           model
         );
-        conditions[i] = enriched;
-      } else {
-        const relation = hops[0];
-        const rel = model.getRelation(`${sourceTable}.${relation}`);
-        if (!rel) {
-          throw new Error(
-            `exists('${relation}'): no relation '${relation}' is declared on table '${sourceTable}'. Use rawExists(subquery(...)) for an EXISTS over an undeclared or uncorrelated subquery.`
-          );
+      }
+      const contextSourceTable = context.sourceTable;
+      const stubIdx = stubs.findIndex((s, idx) => {
+        if (consumedStubIndices.has(idx)) return false;
+        if (contextRelationPath) {
+          const stubPath = normalizeStubRelationPath(s.decision.targetTable);
+          return stubPath === contextRelationPath;
         }
-        const foreignKey = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
-        const relationType = rel.type === "belongsTo" ? "belongsTo" : rel.type === "hasMany" || rel.type === "hasOne" ? rel.type : void 0;
-        const parentKey = relationType === "belongsTo" ? rel.targetKey : rel.sourceKey;
-        const targetTable = rel.target;
-        let innerConditions;
-        if (rawWhere) {
-          const c = convertWhereToDecisions(rawWhere, targetTable);
-          if (c.length > 0) innerConditions = c;
+        if (contextSourceTable !== void 0 && contextSourceTable !== plan.rootTable) {
+          return false;
         }
-        const includeDecisions = rawInclude ? Object.entries(rawInclude).map(([rel2, opts]) => ({
-          type: "existsInclude",
-          relation: rel2,
-          joinType: opts.join ?? "inner"
-        })) : void 0;
-        const enriched = {
-          type: "where",
-          operator: d.operator,
-          targetTable,
-          sourceTable,
-          ...foreignKey ? { foreignKey } : {},
-          ...relationType ? { relationType } : {},
-          ...parentKey ? { parentKey } : {},
-          ...innerConditions ? { conditions: innerConditions } : {},
-          ...includeDecisions ? { include: includeDecisions } : {}
-        };
-        conditions[i] = enriched;
-        if (innerConditions && innerConditions.length > 0) {
-          enrichExistsStubsInConditions(innerConditions, targetTable, model);
+        const stubRelation = normalizeStubRelation(s.decision.targetTable);
+        return stubRelation === context.relation || stubRelation === context.target || stubRelation === context.includeAlias;
+      });
+      if (stubIdx >= 0) {
+        const stub = stubs[stubIdx];
+        if (stub) {
+          stub.container[stub.index] = enriched;
+          consumedStubIndices.add(stubIdx);
+          placedDecisions.push(enriched);
+        }
+      } else {
+        const srcForKey = context.sourceTable ?? "";
+        const targetName = context.target;
+        const relationPath = contextRelationPath;
+        const compoundTarget = targetName ? `${srcForKey}:${targetName}` : "";
+        const compoundPath = relationPath ? `${srcForKey}:${relationPath}` : "";
+        if (compoundTarget && nestedExistsTargets.has(compoundTarget) || compoundPath && nestedExistsTargets.has(compoundPath)) {
+          continue;
         }
+        decisions.push(enriched);
+        placedDecisions.push(enriched);
       }
-    } else if ((d.type === "whereAnd" || d.type === "whereOr" || d.type === "whereNot") && d.conditions) {
-      enrichExistsStubsInConditions(
-        d.conditions,
-        sourceTable,
-        model
+    }
+  }
+  for (let i = 0; i < stubs.length; i++) {
+    if (consumedStubIndices.has(i)) continue;
+    const stub = stubs[i];
+    if (!stub) continue;
+    const rawTargetTable = stub.decision.targetTable;
+    const relationPath = Array.isArray(rawTargetTable) ? rawTargetTable : [rawTargetTable];
+    const displayName = Array.isArray(rawTargetTable) ? rawTargetTable.join(".") : String(rawTargetTable ?? "");
+    if (!displayName) continue;
+    if (!model) {
+      throw new Error(
+        `exists('${displayName}'): cannot resolve relation '${displayName}' on table '${plan.rootTable}' \u2014 no model is configured. Use rawExists(subquery(...)) for an EXISTS over an uncorrelated or undeclared subquery.`
+      );
+    }
+    let currentSource = plan.rootTable;
+    let allHopsDeclared = true;
+    for (const hop of relationPath) {
+      if (!hop) {
+        allHopsDeclared = false;
+        break;
+      }
+      const rel = model.getRelation(`${currentSource}.${hop}`);
+      if (!rel) {
+        allHopsDeclared = false;
+        break;
+      }
+      currentSource = rel.target;
+    }
+    if (!allHopsDeclared) {
+      throw new Error(
+        `exists('${displayName}'): no relation '${displayName}' is declared on table '${plan.rootTable}'. Use rawExists(subquery(...)) for an EXISTS over an undeclared or uncorrelated subquery.`
       );
     }
   }
+  return placedDecisions;
+}
+function extractAllIncludeDecisions(plan, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
+  const includeDecisions = plan.decisions.filter(
+    (d) => d.type === "include-strategy"
+  );
+  if (includeDecisions.length === 0) return [];
+  const treeStrategies = /* @__PURE__ */ new Set(["json_agg", "subquery", "lateral"]);
+  const treeDecisions = [];
+  const flatDecisions = [];
+  for (const d of includeDecisions) {
+    const choice = d.choice;
+    if (treeStrategies.has(choice)) {
+      const converted = toIncludeDecision(d, choice, plan, defaultPk, deriveFk);
+      if (converted) treeDecisions.push(converted);
+    } else if (choice === "join") {
+      const converted = toJoinIncludeDecision(d, plan, defaultPk, deriveFk);
+      if (converted) flatDecisions.push(converted);
+    } else if (choice === "cte") {
+      const converted = toIncludeDecision(d, choice, plan, defaultPk, deriveFk);
+      if (converted) flatDecisions.push(converted);
+    }
+  }
+  const builtTree = buildIncludeTree(treeDecisions);
+  return [...builtTree, ...flatDecisions];
+}
+function toIncludeDecision(d, choice, plan, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
+  const context = d.context;
+  const relationName = resolveIncludeAlias(context);
+  if (!context.target || !relationName) return void 0;
+  const foreignKey = deriveForeignKey(context, deriveFk, defaultPk) ?? defaultPk;
+  const relationType = context.relationType;
+  const effectiveChoice = choice === "subquery" ? "json_agg" : choice;
+  const includeIntent = resolveIncludeByPath(
+    plan.intent?.include,
+    context.intentPath,
+    relationName
+  );
+  const limit = includeIntent?.limit;
+  return {
+    type: "includeStrategy",
+    choice: effectiveChoice,
+    relationName,
+    relationPath: deriveRelationPathFromIntentPath(
+      Array.isArray(plan.intent?.include) ? plan.intent.include : void 0,
+      context.intentPath,
+      relationName
+    ) ?? relationName,
+    targetTable: context.target,
+    ...context.sourceTable && { sourceTable: context.sourceTable },
+    ...relationType && { relationType },
+    foreignKey: Array.isArray(foreignKey) ? foreignKey[0] : foreignKey,
+    parentKey: defaultPk,
+    ...context.intentPath && { intentPath: context.intentPath },
+    ...limit != null && { limit }
+  };
 }
-function buildEnrichedExistsDecision(d, matchingIntent, rootTable, model) {
+function toJoinIncludeDecision(d, plan, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
   const context = d.context;
-  const targetTable = context.target;
+  const relationName = context.relation ?? context.includeAlias;
+  if (!context.target || !relationName) return void 0;
+  const intentPath = context?.intentPath;
+  const relationPath = deriveRelationPathFromIntentPath(
+    Array.isArray(plan.intent?.include) ? plan.intent.include : void 0,
+    intentPath,
+    relationName
+  ) ?? relationName;
+  const includeIntent = resolveIncludeByPath(
+    plan.intent?.include,
+    intentPath,
+    relationName
+  );
+  let columns = [defaultPk];
+  if (includeIntent?.select?.type === "fields" && includeIntent.select.fields) {
+    const fields = includeIntent.select.fields.filter((f) => f !== defaultPk);
+    columns = [defaultPk, ...fields];
+  }
+  const foreignKey = deriveForeignKey(context, deriveFk, defaultPk) ?? defaultPk;
+  const relationType = context.relationType;
   let conditions;
-  if (matchingIntent?.where) {
-    const nestedDecisions = convertWhereToDecisions(
-      matchingIntent.where,
-      targetTable
+  if (includeIntent?.where) {
+    const converted = convertWhereToDecisions(
+      includeIntent.where,
+      relationName
     );
-    if (nestedDecisions.length > 0) {
-      conditions = nestedDecisions;
-      if (model) {
-        enrichExistsStubsInConditions(conditions, targetTable, model);
-      }
+    if (converted.length > 0) {
+      conditions = converted;
     }
   }
-  const sourceTableForRelation = context.sourceTable || rootTable;
-  const relIR = model && context.relation ? model.getRelation(
-    `${sourceTableForRelation}.${context.relation}`
-  ) : void 0;
-  const foreignKey = relIR ? typeof relIR.foreignKey === "string" ? relIR.foreignKey : relIR.foreignKey?.[0] : void 0;
-  const relationType = relIR?.type === "belongsTo" ? "belongsTo" : relIR?.type === "hasMany" || relIR?.type === "hasOne" ? relIR.type : void 0;
-  const parentKey = relationType === "belongsTo" ? relIR?.targetKey : relIR?.sourceKey;
-  let operator = "exists";
-  if (matchingIntent?.kind === "notExists") {
-    operator = "notExists";
-  } else if (matchingIntent?.kind === "relationFilter") {
-    const mode = matchingIntent.mode ?? "some";
-    if (mode === "none") operator = "notExists";
-    else if (mode === "every") operator = "every";
-  }
-  const includeIntent = matchingIntent?.include;
-  const includeDecisions = includeIntent ? Object.entries(includeIntent).map(([rel, opts]) => ({
-    type: "existsInclude",
-    relation: rel,
-    joinType: opts.join ?? "inner"
-  })) : void 0;
-  const relationName = context.relation;
+  const joinType = d.joinType;
   return {
-    type: "where",
-    operator,
-    targetTable,
-    // sourceTable: the table this EXISTS is resolved FROM (the relation's source).
-    // Required by propagateExistsConditions's (sourceTable, relationName) identity
-    // guard — without it the guard is a no-op and cross-source propagation can occur
-    // when two relations share a name but originate from different tables.
-    sourceTable: sourceTableForRelation,
-    ...foreignKey ? { foreignKey } : {},
-    // relationType is required so deriveFkColumns (called by mapToHandlerDecision) can
-    // set sourceColumn/targetColumn in the correct direction for the EXISTS correlation.
-    ...relationType ? { relationType } : {},
-    // parentKey provides the explicit PK override for non-default PK columns.
-    ...parentKey ? { parentKey } : {},
-    ...conditions ? { conditions } : {},
-    ...d.choice === "join" ? { choice: "join" } : {},
-    ...relationName ? { relationName } : {},
-    ...includeDecisions ? { include: includeDecisions } : {}
+    type: "includeStrategy",
+    choice: "join",
+    relationName,
+    relationPath,
+    targetTable: context.target,
+    ...context.sourceTable && { sourceTable: context.sourceTable },
+    ...relationType && { relationType },
+    foreignKey: Array.isArray(foreignKey) ? foreignKey[0] : foreignKey,
+    parentKey: defaultPk,
+    columns,
+    ...joinType && { joinType },
+    ...conditions && { conditions }
   };
 }
-function collectNestedExistsTargets(where, insideExists, sourceTable, model, out) {
-  if (!where || typeof where !== "object") return;
-  const w = where;
-  if (w.kind === "exists" || w.kind === "notExists" || w.kind === "relationFilter") {
-    if (insideExists) {
-      const rawRelation = w.relation;
-      const hops = Array.isArray(rawRelation) ? rawRelation : typeof rawRelation === "string" ? [rawRelation] : [];
-      if (hops.length === 1) {
-        const singleHop = hops[0] ?? "";
-        const rel = model.getRelation(`${sourceTable}.${singleHop}`);
-        const resolvedTarget = rel ? rel.target : singleHop;
-        out.add(`${sourceTable}:${resolvedTarget}`);
-      } else if (hops.length > 1) {
-        let penultimate = sourceTable;
-        for (let hi = 0; hi < hops.length - 1; hi++) {
-          const hr = model.getRelation(`${penultimate}.${hops[hi] ?? ""}`);
-          penultimate = hr ? hr.target : hops[hi] ?? penultimate;
-        }
-        out.add(`${penultimate}:${hops.join(".")}`);
-        const lastHop = hops[hops.length - 1] ?? "";
-        const lastRel = model.getRelation(`${penultimate}.${lastHop}`);
-        const finalTarget = lastRel ? lastRel.target : lastHop;
-        out.add(`${penultimate}:${finalTarget}`);
-      }
-      let nextSource = sourceTable;
-      if (hops.length >= 1) {
-        let cur = sourceTable;
-        for (const hop of hops) {
-          const rel = model.getRelation(`${cur}.${hop}`);
-          cur = rel ? rel.target : hop;
-        }
-        nextSource = cur;
-      }
-      if (w.where) {
-        collectNestedExistsTargets(w.where, true, nextSource, model, out);
-      }
+function snakeToCamel(s) {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function synthesizeMissingJoinDecisions(plan, coveredRelations, model, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
+  const includes = plan.intent?.include;
+  if (!includes || includes.length === 0) return [];
+  const sourceTable = plan.rootTable;
+  const relationsFromSource = model.getRelationsFrom(sourceTable);
+  const synthesized = [];
+  for (const inc of includes) {
+    const alias = inc.relation;
+    if (inc.join !== "inner" && inc.join !== "left") continue;
+    if (coveredRelations.has(alias)) continue;
+    const rel = relationsFromSource.find(
+      (r) => r.name === alias || snakeToCamel(r.name) === alias
+    );
+    if (!rel) continue;
+    const rawFk = rel.foreignKey ? Array.isArray(rel.foreignKey) ? rel.foreignKey[0] : rel.foreignKey : deriveFk(
+      rel.type === "belongsTo" ? rel.target : sourceTable,
+      defaultPk
+    );
+    let columns = [defaultPk];
+    if (inc.select?.type === "fields" && inc.select.fields) {
+      const extraFields = inc.select.fields.filter((f) => f !== defaultPk);
+      columns = [defaultPk, ...extraFields];
+    }
+    let conditions;
+    if (inc.where) {
+      const converted = convertWhereToDecisions(inc.where, alias);
+      if (converted.length > 0) conditions = converted;
+    }
+    synthesized.push({
+      type: "includeStrategy",
+      choice: "join",
+      relationName: alias,
+      relationPath: alias,
+      targetTable: rel.target,
+      sourceTable,
+      ...rel.type && {
+        relationType: rel.type
+      },
+      foreignKey: Array.isArray(rawFk) ? rawFk[0] : rawFk,
+      parentKey: defaultPk,
+      columns,
+      joinType: inc.join,
+      ...conditions && { conditions }
+    });
+  }
+  return synthesized;
+}
+function buildIncludeTree(allDecisions) {
+  const decisionsByPath = /* @__PURE__ */ new Map();
+  for (const d of allDecisions) {
+    if (d.intentPath) decisionsByPath.set(d.intentPath, d);
+  }
+  function parentPath(path) {
+    const lastDot = path.lastIndexOf(".include[");
+    return lastDot > 0 ? path.substring(0, lastDot) : void 0;
+  }
+  const childrenMap = /* @__PURE__ */ new Map();
+  const rootDecisions = [];
+  for (const d of allDecisions) {
+    const pp = d.intentPath ? parentPath(d.intentPath) : void 0;
+    if (pp && decisionsByPath.has(pp)) {
+      const siblings = childrenMap.get(pp) ?? [];
+      siblings.push(d);
+      childrenMap.set(pp, siblings);
     } else {
-      const rawRelation = w.relation;
-      const hops = Array.isArray(rawRelation) ? rawRelation : typeof rawRelation === "string" ? [rawRelation] : [];
-      let nextSource = sourceTable;
-      if (hops.length >= 1) {
-        let cur = sourceTable;
-        for (const hop of hops) {
-          const rel = model.getRelation(`${cur}.${hop}`);
-          cur = rel ? rel.target : hop;
-        }
-        nextSource = cur;
-      }
-      if (w.where) {
-        collectNestedExistsTargets(w.where, true, nextSource, model, out);
-      }
+      rootDecisions.push(d);
+    }
+  }
+  function attachChildren(decision) {
+    const path = decision.intentPath;
+    const children = path ? childrenMap.get(path) : void 0;
+    if (!children || children.length === 0) return decision;
+    return {
+      ...decision,
+      children: children.map(attachChildren)
+    };
+  }
+  return rootDecisions.map(attachChildren);
+}
+
+// src/adapter-compiler-select.ts
+var ADAPTER_MULTIWORD_BASE_TYPES = [
+  "timestamp with time zone",
+  "timestamp without time zone",
+  "time with time zone",
+  "time without time zone",
+  "double precision",
+  "character varying",
+  "bit varying"
+];
+var ADAPTER_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSafeTypeName(typeName, colIndex) {
+  const raw = typeName.trim();
+  if (raw.length === 0) {
+    throw new Error(
+      `BatchValues compile error: type name at column index ${colIndex} must not be empty.`
+    );
+  }
+  let rest = raw;
+  if (rest.endsWith("[]")) {
+    rest = rest.slice(0, -2);
+    if (rest.endsWith("[]")) {
+      throw new Error(
+        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. At most one array suffix "[]" is allowed as a raw type-name input.`
+      );
+    }
+  }
+  const modifierMatch = rest.match(/\(([^)]*)\)$/);
+  if (modifierMatch) {
+    const inner = modifierMatch[1] ?? "";
+    if (!/^\d+(?:,\d+)?$/.test(inner)) {
+      throw new Error(
+        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Type modifier must be "(N)" or "(N,M)" with digits only; got "(${inner})".`
+      );
     }
-    return;
+    rest = rest.slice(0, rest.length - modifierMatch[0].length).trimEnd();
   }
-  if (w.conditions && Array.isArray(w.conditions)) {
-    for (const c of w.conditions) {
-      collectNestedExistsTargets(c, insideExists, sourceTable, model, out);
-    }
+  const baseLower = rest.toLowerCase();
+  if (ADAPTER_MULTIWORD_BASE_TYPES.includes(baseLower)) {
+    return;
   }
-  if (w.condition) {
-    collectNestedExistsTargets(
-      w.condition,
-      insideExists,
-      sourceTable,
-      model,
-      out
+  const parts = rest.split(".");
+  if (parts.length > 2) {
+    throw new Error(
+      `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Schema-qualified types allow at most one dot (schema.type).`
     );
   }
-}
-function collectExistsStubs(decisions, out) {
-  decisions.forEach((d, i) => {
-    if (!d) return;
-    if (d.type === "where" && (d.operator === "exists" || d.operator === "notExists" || d.operator === "every")) {
-      if (d.relationName) return;
-      out.push({ decision: d, container: decisions, index: i });
-    } else if ((d.type === "whereAnd" || d.type === "whereOr" || d.type === "whereNot") && d.conditions) {
-      collectExistsStubs(d.conditions, out);
+  for (const part of parts) {
+    if (!ADAPTER_IDENT_RE.test(part)) {
+      throw new Error(
+        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Base type "${part}" is not a valid SQL identifier and is not in the multi-word type allowlist.`
+      );
     }
-  });
-}
-function normalizeStubRelation(targetTable) {
-  if (Array.isArray(targetTable) && targetTable.length > 0)
-    return targetTable[targetTable.length - 1];
-  if (typeof targetTable === "string") return targetTable;
-  return void 0;
+  }
 }
-function normalizeStubRelationPath(targetTable) {
-  if (Array.isArray(targetTable) && targetTable.length > 0)
-    return targetTable.join(".");
-  if (typeof targetTable === "string") return targetTable;
-  return void 0;
+function bridgeLegacyDecisions(decisions) {
+  return decisions;
 }
-function enrichExistsDecisionsInPlace(decisions, plan, model) {
-  const stubs = [];
-  collectExistsStubs(decisions, stubs);
-  const nestedExistsTargets = /* @__PURE__ */ new Set();
-  if (plan.intent?.where && model) {
-    collectNestedExistsTargets(
-      plan.intent.where,
-      false,
-      plan.rootTable,
-      model,
-      nestedExistsTargets
-    );
+function buildBatchValuesRangeFn(bv, startParamIndex, aliasOverride) {
+  const params = [];
+  let paramIdx = startParamIndex - 1;
+  const effectiveAlias = aliasOverride ?? bv.alias;
+  for (let ci = 0; ci < bv.columns.length; ci++) {
+    const rawType = bv.types[ci];
+    if (rawType) assertSafeTypeName(rawType, ci);
   }
-  const filterDecisions = plan.decisions.filter(
-    (d) => d.type === "filter-strategy" && (d.choice === "exists" || d.choice === "notExists" || d.choice === "join")
+  const unnestArgs = bv.columns.map((col, i) => {
+    const colArray = bv.data[i] ?? [];
+    let pgBaseType;
+    if (bv.types[i]) {
+      const rawType = bv.types[i];
+      pgBaseType = rawType.endsWith("[]") ? rawType.slice(0, -2) : rawType;
+    } else {
+      const sampleValue = colArray.find((v) => v !== null && v !== void 0);
+      const pgArrayType = inferPgArrayType(col, {}, sampleValue);
+      pgBaseType = stripArraySuffix(pgArrayType);
+    }
+    params.push(colArray);
+    paramIdx++;
+    return createTypeCastParamRef(paramIdx, pgBaseType, true);
+  });
+  const unnestCall = funcCall("unnest", unnestArgs);
+  const colnames = [...bv.columns, ...bv.ordinality ? ["ord"] : []].map(
+    (c) => ({ String: { sval: c } })
   );
-  const placedDecisions = [];
-  const consumedStubIndices = /* @__PURE__ */ new Set();
-  if (filterDecisions.length > 0) {
-    const existsIntents = plan.intent?.where ? findExistsIntents(plan.intent.where) : [];
-    for (const d of filterDecisions) {
-      const context = d.context;
-      if (!context.target) continue;
-      const contextRelationPath = context.relationPath;
-      const contextSourceTableForIntent = context.sourceTable;
-      const isNestedRelation = contextSourceTableForIntent !== void 0 && contextSourceTableForIntent !== plan.rootTable && !contextRelationPath;
-      const matchIdx = isNestedRelation ? -1 : existsIntents.findIndex((i) => {
-        if (contextRelationPath) {
-          const intentPath = Array.isArray(i.relation) ? i.relation.join(".") : typeof i.relation === "string" ? i.relation : void 0;
-          return intentPath === contextRelationPath;
-        }
-        const rel = Array.isArray(i.relation) ? i.relation.length > 0 ? i.relation[i.relation.length - 1] : void 0 : typeof i.relation === "string" ? i.relation : void 0;
-        return rel === context.relation || rel === context.target || rel === context.includeAlias;
+  const rangeFunction = {
+    RangeFunction: {
+      functions: [{ List: { items: [unnestCall] } }],
+      ordinality: bv.ordinality,
+      alias: { aliasname: effectiveAlias, colnames }
+    }
+  };
+  return { rangeFunction, params };
+}
+function compileJoinIntents(joins, rootTable, schemaName, deps) {
+  if (joins.length === 0) return [];
+  const model = deps.model;
+  const naming = deps.naming;
+  const deriveFk = deps.deriveFk ?? defaultFkDerivation;
+  const defaultPk = deps.defaultPk;
+  const results = [];
+  for (const intent of joins) {
+    if (intent.relation !== void 0) {
+      if (!model) {
+        throw new Error(
+          `join('${intent.relation}'): relation-mode join requires a model for FK resolution.`
+        );
+      }
+      const relationsFromRoot = model.getRelationsFrom(rootTable);
+      const rel = relationsFromRoot.find((r) => r.name === intent.relation);
+      if (!rel) {
+        throw new Error(
+          `join('${intent.relation}'): relation not found on table '${rootTable}'. Available: ${relationsFromRoot.map((r) => r.name).join(", ")}`
+        );
+      }
+      const isBelongsTo = rel.type === "belongsTo";
+      const rawFk = rel.foreignKey ? Array.isArray(rel.foreignKey) ? rel.foreignKey[0] : rel.foreignKey : deriveFk(isBelongsTo ? rootTable : rel.target, defaultPk);
+      const sourceColumn = isBelongsTo ? rawFk : defaultPk;
+      const targetColumn = isBelongsTo ? defaultPk : rawFk;
+      const alias = intent.alias ?? intent.relation;
+      results.push({
+        type: "join",
+        targetTable: rel.target,
+        alias,
+        sourceColumn,
+        targetColumn,
+        joinType: intent.type
       });
-      const matchingIntent = matchIdx >= 0 ? existsIntents[matchIdx] : void 0;
-      if (matchIdx >= 0) existsIntents.splice(matchIdx, 1);
-      const isMultiHop = matchingIntent && Array.isArray(matchingIntent.relation) && matchingIntent.relation.length > 1 && model;
-      let enriched;
-      if (isMultiHop && matchingIntent && model) {
-        const mode = matchingIntent.mode ?? "some";
-        const isEvery = matchingIntent.kind !== "notExists" && mode === "every";
-        const outerOperator = matchingIntent.kind === "notExists" || mode === "none" || isEvery ? "notExists" : "exists";
-        const lastHopTarget = context.target;
-        const rawInnerConditions = matchingIntent.where ? (() => {
-          const c = convertWhereToDecisions(
-            matchingIntent.where,
-            lastHopTarget
-          );
-          if (c.length > 0) {
-            enrichExistsStubsInConditions(c, lastHopTarget, model);
-          }
-          return c.length > 0 ? c : void 0;
-        })() : void 0;
-        if (isEvery && !rawInnerConditions) {
-          enriched = buildEnrichedExistsDecision(
-            d,
-            matchingIntent,
-            plan.rootTable,
-            model
-          );
-        } else {
-          const innerConditions = isEvery && rawInnerConditions ? [
-            {
-              type: "logical",
-              operator: "not",
-              conditions: rawInnerConditions
-            }
-          ] : rawInnerConditions;
-          enriched = buildMultiHopExistsChain(
-            matchingIntent.relation,
-            plan.rootTable,
-            outerOperator,
-            innerConditions,
-            model
+    } else if (intent.batchValues !== void 0) {
+      const bv = intent.batchValues;
+      const alias = intent.alias ?? bv.alias;
+      const { rangeFunction, params: bvParams } = buildBatchValuesRangeFn(
+        bv,
+        1,
+        alias
+      );
+      const bvOnParamState = createCompilerState();
+      bvOnParamState.paramIndex = bvParams.length;
+      const bvCtx = {
+        rootTable,
+        aliases: /* @__PURE__ */ new Map(),
+        paramState: bvOnParamState,
+        naming,
+        outerTable: alias,
+        ...schemaName !== void 0 && { schemaName },
+        ...deps.bindingNames !== void 0 && {
+          bindingNames: deps.bindingNames
+        },
+        ...model !== void 0 && { model },
+        ...deps.dialectCapabilities !== void 0 && {
+          dialectCapabilities: deps.dialectCapabilities
+        },
+        compileSubquery: () => {
+          throw new Error(
+            "Subquery in BatchValues JOIN ON condition is not supported."
           );
         }
-      } else {
-        enriched = buildEnrichedExistsDecision(
-          d,
-          matchingIntent,
-          plan.rootTable,
-          model
-        );
+      };
+      const onNode = compileWhereIntent(intent.on, bvCtx);
+      const allBvParams = [
+        ...bvParams,
+        ...bvOnParamState.parameters
+      ];
+      results.push({
+        type: "join",
+        targetTable: alias,
+        alias,
+        joinType: intent.type,
+        joinRarg: rangeFunction,
+        joinOnNode: onNode,
+        // batchValuesParams are spliced into this.state.parameters BEFORE
+        // other params in compiler.ts, so $1/$2/... refs align correctly.
+        batchValuesParams: allBvParams
+      });
+    } else {
+      const paramState = createCompilerState();
+      const tableAlias = intent.alias ?? intent.table;
+      const tableAliasMap = /* @__PURE__ */ new Map();
+      tableAliasMap.set(rootTable, rootTable);
+      if (tableAlias !== rootTable) {
+        tableAliasMap.set(tableAlias, intent.table);
       }
-      const contextSourceTable = context.sourceTable;
-      const stubIdx = stubs.findIndex((s, idx) => {
-        if (consumedStubIndices.has(idx)) return false;
-        if (contextRelationPath) {
-          const stubPath = normalizeStubRelationPath(s.decision.targetTable);
-          return stubPath === contextRelationPath;
-        }
-        if (contextSourceTable !== void 0 && contextSourceTable !== plan.rootTable) {
-          return false;
+      const ctx = {
+        rootTable,
+        aliases: tableAliasMap,
+        paramState,
+        naming,
+        // outerTable = tableAlias so FieldRef(scope:'outer') resolves to the
+        // joined alias (e.g. 'e2' in self-join ON conditions).
+        outerTable: tableAlias,
+        ...schemaName !== void 0 && { schemaName },
+        ...deps.bindingNames !== void 0 && {
+          bindingNames: deps.bindingNames
+        },
+        ...model !== void 0 && { model },
+        ...deps.dialectCapabilities !== void 0 && {
+          dialectCapabilities: deps.dialectCapabilities
+        },
+        compileSubquery: () => {
+          throw new Error("Subquery in JOIN ON condition is not supported.");
         }
-        const stubRelation = normalizeStubRelation(s.decision.targetTable);
-        return stubRelation === context.relation || stubRelation === context.target || stubRelation === context.includeAlias;
+      };
+      const onNode = compileWhereIntent(intent.on, ctx);
+      const joinedRangeVar = rangeVar(
+        intent.table,
+        tableAlias,
+        schemaForFromName(schemaName, intent.table, deps.bindingNames, naming),
+        naming
+      );
+      results.push({
+        type: "join",
+        targetTable: intent.table,
+        alias: tableAlias,
+        joinType: intent.type,
+        joinRarg: joinedRangeVar,
+        joinOnNode: onNode
       });
-      if (stubIdx >= 0) {
-        const stub = stubs[stubIdx];
-        if (stub) {
-          stub.container[stub.index] = enriched;
-          consumedStubIndices.add(stubIdx);
-          placedDecisions.push(enriched);
-        }
-      } else {
-        const srcForKey = context.sourceTable ?? "";
-        const targetName = context.target;
-        const relationPath = contextRelationPath;
-        const compoundTarget = targetName ? `${srcForKey}:${targetName}` : "";
-        const compoundPath = relationPath ? `${srcForKey}:${relationPath}` : "";
-        if (compoundTarget && nestedExistsTargets.has(compoundTarget) || compoundPath && nestedExistsTargets.has(compoundPath)) {
-          continue;
-        }
-        decisions.push(enriched);
-        placedDecisions.push(enriched);
-      }
     }
   }
-  for (let i = 0; i < stubs.length; i++) {
-    if (consumedStubIndices.has(i)) continue;
-    const stub = stubs[i];
-    if (!stub) continue;
-    const rawTargetTable = stub.decision.targetTable;
-    const relationPath = Array.isArray(rawTargetTable) ? rawTargetTable : [rawTargetTable];
-    const displayName = Array.isArray(rawTargetTable) ? rawTargetTable.join(".") : String(rawTargetTable ?? "");
-    if (!displayName) continue;
-    if (!model) {
-      throw new Error(
-        `exists('${displayName}'): cannot resolve relation '${displayName}' on table '${plan.rootTable}' \u2014 no model is configured. Use rawExists(subquery(...)) for an EXISTS over an uncorrelated or undeclared subquery.`
-      );
-    }
-    let currentSource = plan.rootTable;
-    let allHopsDeclared = true;
-    for (const hop of relationPath) {
-      if (!hop) {
-        allHopsDeclared = false;
-        break;
-      }
-      const rel = model.getRelation(`${currentSource}.${hop}`);
-      if (!rel) {
-        allHopsDeclared = false;
-        break;
+  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 = [];
       }
-      currentSource = rel.target;
-    }
-    if (!allHopsDeclared) {
-      throw new Error(
-        `exists('${displayName}'): no relation '${displayName}' is declared on table '${plan.rootTable}'. Use rawExists(subquery(...)) for an EXISTS over an undeclared or uncorrelated subquery.`
-      );
     }
   }
-  return placedDecisions;
 }
-function extractAllIncludeDecisions(plan, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
-  const includeDecisions = plan.decisions.filter(
-    (d) => d.type === "include-strategy"
-  );
-  if (includeDecisions.length === 0) return [];
-  const treeStrategies = /* @__PURE__ */ new Set(["json_agg", "subquery", "lateral"]);
-  const treeDecisions = [];
-  const flatDecisions = [];
-  for (const d of includeDecisions) {
-    const choice = d.choice;
-    if (treeStrategies.has(choice)) {
-      const converted = toIncludeDecision(d, choice, plan, defaultPk, deriveFk);
-      if (converted) treeDecisions.push(converted);
-    } else if (choice === "join") {
-      const converted = toJoinIncludeDecision(d, plan, defaultPk, deriveFk);
-      if (converted) flatDecisions.push(converted);
-    } else if (choice === "cte") {
-      const converted = toIncludeDecision(d, choice, plan, defaultPk, deriveFk);
-      if (converted) flatDecisions.push(converted);
+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 builtTree = buildIncludeTree(treeDecisions);
-  return [...builtTree, ...flatDecisions];
-}
-function toIncludeDecision(d, choice, plan, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
-  const context = d.context;
-  const relationName = resolveIncludeAlias(context);
-  if (!context.target || !relationName) return void 0;
-  const foreignKey = deriveForeignKey(context, deriveFk, defaultPk) ?? defaultPk;
-  const relationType = context.relationType;
-  const effectiveChoice = choice === "subquery" ? "json_agg" : choice;
-  const includeIntent = resolveIncludeByPath(
-    plan.intent?.include,
-    context.intentPath,
-    relationName
-  );
-  const limit = includeIntent?.limit;
-  return {
-    type: "includeStrategy",
-    choice: effectiveChoice,
-    relationName,
-    relationPath: deriveRelationPathFromIntentPath(
-      Array.isArray(plan.intent?.include) ? plan.intent.include : void 0,
-      context.intentPath,
-      relationName
-    ) ?? relationName,
-    targetTable: context.target,
-    ...context.sourceTable && { sourceTable: context.sourceTable },
-    ...relationType && { relationType },
-    foreignKey: Array.isArray(foreignKey) ? foreignKey[0] : foreignKey,
-    parentKey: defaultPk,
-    ...context.intentPath && { intentPath: context.intentPath },
-    ...limit != null && { limit }
-  };
-}
-function toJoinIncludeDecision(d, plan, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
-  const context = d.context;
-  const relationName = context.relation ?? context.includeAlias;
-  if (!context.target || !relationName) return void 0;
-  const intentPath = context?.intentPath;
-  const relationPath = deriveRelationPathFromIntentPath(
-    Array.isArray(plan.intent?.include) ? plan.intent.include : void 0,
-    intentPath,
-    relationName
-  ) ?? relationName;
-  const includeIntent = resolveIncludeByPath(
-    plan.intent?.include,
-    intentPath,
-    relationName
-  );
-  let columns = [defaultPk];
-  if (includeIntent?.select?.type === "fields" && includeIntent.select.fields) {
-    const fields = includeIntent.select.fields.filter((f) => f !== defaultPk);
-    columns = [defaultPk, ...fields];
-  }
-  const foreignKey = deriveForeignKey(context, deriveFk, defaultPk) ?? defaultPk;
-  const relationType = context.relationType;
-  let conditions;
-  if (includeIntent?.where) {
-    const converted = convertWhereToDecisions(
-      includeIntent.where,
-      relationName
-    );
-    if (converted.length > 0) {
-      conditions = converted;
+    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 } }]);
     }
   }
-  const joinType = d.joinType;
-  return {
-    type: "includeStrategy",
-    choice: "join",
-    relationName,
-    relationPath,
-    targetTable: context.target,
-    ...context.sourceTable && { sourceTable: context.sourceTable },
-    ...relationType && { relationType },
-    foreignKey: Array.isArray(foreignKey) ? foreignKey[0] : foreignKey,
-    parentKey: defaultPk,
-    columns,
-    ...joinType && { joinType },
-    ...conditions && { conditions }
-  };
-}
-function snakeToCamel(s) {
-  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  return map;
 }
-function synthesizeMissingJoinDecisions(plan, coveredRelations, model, defaultPk = DEFAULT_PK_COLUMN, deriveFk = defaultFkDerivation) {
-  const includes = plan.intent?.include;
-  if (!includes || includes.length === 0) return [];
-  const sourceTable = plan.rootTable;
-  const relationsFromSource = model.getRelationsFrom(sourceTable);
-  const synthesized = [];
-  for (const inc of includes) {
-    const alias = inc.relation;
-    if (inc.join !== "inner" && inc.join !== "left") continue;
-    if (coveredRelations.has(alias)) continue;
-    const rel = relationsFromSource.find(
-      (r) => r.name === alias || snakeToCamel(r.name) === alias
-    );
-    if (!rel) continue;
-    const rawFk = rel.foreignKey ? Array.isArray(rel.foreignKey) ? rel.foreignKey[0] : rel.foreignKey : deriveFk(
-      rel.type === "belongsTo" ? rel.target : sourceTable,
-      defaultPk
-    );
-    let columns = [defaultPk];
-    if (inc.select?.type === "fields" && inc.select.fields) {
-      const extraFields = inc.select.fields.filter((f) => f !== defaultPk);
-      columns = [defaultPk, ...extraFields];
-    }
-    let conditions;
-    if (inc.where) {
-      const converted = convertWhereToDecisions(inc.where, alias);
-      if (converted.length > 0) conditions = converted;
+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(", ")}`
+          );
+        }
+      }
     }
-    synthesized.push({
-      type: "includeStrategy",
-      choice: "join",
-      relationName: alias,
-      relationPath: alias,
-      targetTable: rel.target,
-      sourceTable,
-      ...rel.type && {
-        relationType: rel.type
-      },
-      foreignKey: Array.isArray(rawFk) ? rawFk[0] : rawFk,
-      parentKey: defaultPk,
-      columns,
-      joinType: inc.join,
-      ...conditions && { conditions }
-    });
   }
-  return synthesized;
 }
-function buildIncludeTree(allDecisions) {
-  const decisionsByPath = /* @__PURE__ */ new Map();
-  for (const d of allDecisions) {
-    if (d.intentPath) decisionsByPath.set(d.intentPath, d);
+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 parentPath(path) {
-    const lastDot = path.lastIndexOf(".include[");
-    return lastDot > 0 ? path.substring(0, lastDot) : void 0;
+  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;
   }
-  const childrenMap = /* @__PURE__ */ new Map();
-  const rootDecisions = [];
-  for (const d of allDecisions) {
-    const pp = d.intentPath ? parentPath(d.intentPath) : void 0;
-    if (pp && decisionsByPath.has(pp)) {
-      const siblings = childrenMap.get(pp) ?? [];
-      siblings.push(d);
-      childrenMap.set(pp, siblings);
-    } else {
-      rootDecisions.push(d);
+}
+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 attachChildren(decision) {
-    const path = decision.intentPath;
-    const children = path ? childrenMap.get(path) : void 0;
-    if (!children || children.length === 0) return decision;
+}
+function buildSimplifiedPlanReport(plan, allDecisions, schemaName) {
+  const bvFromSource = plan.intent?.batchValuesSource;
+  const batchValuesFromFields = bvFromSource ? (() => {
+    const { rangeFunction, params } = buildBatchValuesRangeFn(
+      bvFromSource,
+      1
+    );
     return {
-      ...decision,
-      children: children.map(attachChildren)
+      batchValuesFromNode: rangeFunction,
+      batchValuesFromParams: params
     };
-  }
-  return rootDecisions.map(attachChildren);
+  })() : {};
+  return {
+    rootTable: plan.rootTable,
+    decisions: allDecisions,
+    ...schemaName ? { schema: schemaName } : {},
+    ...plan.intent?.existsWrap ? { existsWrap: true } : {},
+    ...plan.intent?.lock ? { lock: plan.intent.lock } : {},
+    ...batchValuesFromFields
+  };
 }
-
-// src/adapter-compiler-select.ts
-var ADAPTER_MULTIWORD_BASE_TYPES = [
-  "timestamp with time zone",
-  "timestamp without time zone",
-  "time with time zone",
-  "time without time zone",
-  "double precision",
-  "character varying",
-  "bit varying"
-];
-var ADAPTER_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function assertSafeTypeName(typeName, colIndex) {
-  const raw = typeName.trim();
-  if (raw.length === 0) {
-    throw new Error(
-      `BatchValues compile error: type name at column index ${colIndex} must not be empty.`
+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
+    },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    ...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
     );
-  }
-  let rest = raw;
-  if (rest.endsWith("[]")) {
-    rest = rest.slice(0, -2);
-    if (rest.endsWith("[]")) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. At most one array suffix "[]" is allowed as a raw type-name input.`
+    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 modifierMatch = rest.match(/\(([^)]*)\)$/);
-  if (modifierMatch) {
-    const inner = modifierMatch[1] ?? "";
-    if (!/^\d+(?:,\d+)?$/.test(inner)) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Type modifier must be "(N)" or "(N,M)" with digits only; got "(${inner})".`
-      );
+    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 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;
     }
-    rest = rest.slice(0, rest.length - modifierMatch[0].length).trimEnd();
-  }
-  const baseLower = rest.toLowerCase();
-  if (ADAPTER_MULTIWORD_BASE_TYPES.includes(baseLower)) {
-    return;
-  }
-  const parts = rest.split(".");
-  if (parts.length > 2) {
-    throw new Error(
-      `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Schema-qualified types allow at most one dot (schema.type).`
-    );
-  }
-  for (const part of parts) {
-    if (!ADAPTER_IDENT_RE.test(part)) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Base type "${part}" is not a valid SQL identifier and is not in the multi-word type allowlist.`
-      );
+    if (includeIntent?.where != null) {
+      entry.where = includeIntent.where;
     }
+    subqueryIncludes.push(entry);
   }
+  return { main, subqueryIncludes };
 }
-function bridgeLegacyDecisions(decisions) {
-  return decisions;
+
+// src/adapter-compiler-mutations.ts
+init_binding_registry();
+init_compile_where();
+init_compiler_utils();
+init_handlers();
+function whereIntentAsDecision(where) {
+  return where;
 }
-function buildBatchValuesRangeFn(bv, startParamIndex, aliasOverride) {
-  const params = [];
-  let paramIdx = startParamIndex - 1;
-  const effectiveAlias = aliasOverride ?? bv.alias;
-  for (let ci = 0; ci < bv.columns.length; ci++) {
-    const rawType = bv.types[ci];
-    if (rawType) assertSafeTypeName(rawType, ci);
-  }
-  const unnestArgs = bv.columns.map((col, i) => {
-    const colArray = bv.data[i] ?? [];
-    let pgBaseType;
-    if (bv.types[i]) {
-      const rawType = bv.types[i];
-      pgBaseType = rawType.endsWith("[]") ? rawType.slice(0, -2) : rawType;
-    } else {
-      const sampleValue = colArray.find((v) => v !== null && v !== void 0);
-      const pgArrayType = inferPgArrayType(col, {}, sampleValue);
-      pgBaseType = stripArraySuffix(pgArrayType);
-    }
-    params.push(colArray);
-    paramIdx++;
-    return createTypeCastParamRef(paramIdx, pgBaseType, true);
+function renumberSqlParams(sql, offset) {
+  if (offset === 0) return sql;
+  return sql.replace(/\$(\d+)/g, (_match, num) => {
+    return `$${Number.parseInt(num, 10) + offset}`;
   });
-  const unnestCall = funcCall("unnest", unnestArgs);
-  const colnames = [...bv.columns, ...bv.ordinality ? ["ord"] : []].map(
-    (c) => ({ String: { sval: c } })
-  );
-  const rangeFunction = {
-    RangeFunction: {
-      functions: [{ List: { items: [unnestCall] } }],
-      ordinality: bv.ordinality,
-      alias: { aliasname: effectiveAlias, colnames }
-    }
-  };
-  return { rangeFunction, params };
 }
-function compileJoinIntents(joins, rootTable, schemaName, deps) {
-  if (joins.length === 0) return [];
+function compileSourceQueryCte(operation, sourceName, sourceQuery, options, deps) {
   const model = deps.model;
-  const naming = deps.naming;
-  const deriveFk = deps.deriveFk ?? defaultFkDerivation;
-  const defaultPk = deps.defaultPk;
-  const results = [];
-  for (const intent of joins) {
-    if (intent.relation !== void 0) {
-      if (!model) {
-        throw new Error(
-          `join('${intent.relation}'): relation-mode join requires a model for FK resolution.`
-        );
-      }
-      const relationsFromRoot = model.getRelationsFrom(rootTable);
-      const rel = relationsFromRoot.find((r) => r.name === intent.relation);
-      if (!rel) {
-        throw new Error(
-          `join('${intent.relation}'): relation not found on table '${rootTable}'. Available: ${relationsFromRoot.map((r) => r.name).join(", ")}`
-        );
-      }
-      const isBelongsTo = rel.type === "belongsTo";
-      const rawFk = rel.foreignKey ? Array.isArray(rel.foreignKey) ? rel.foreignKey[0] : rel.foreignKey : deriveFk(isBelongsTo ? rootTable : rel.target, defaultPk);
-      const sourceColumn = isBelongsTo ? rawFk : defaultPk;
-      const targetColumn = isBelongsTo ? defaultPk : rawFk;
-      const alias = intent.alias ?? intent.relation;
-      results.push({
-        type: "join",
-        targetTable: rel.target,
-        alias,
-        sourceColumn,
-        targetColumn,
-        joinType: intent.type
-      });
-    } else if (intent.batchValues !== void 0) {
-      const bv = intent.batchValues;
-      const alias = intent.alias ?? bv.alias;
-      const { rangeFunction, params: bvParams } = buildBatchValuesRangeFn(
-        bv,
-        1,
-        alias
-      );
-      const bvOnParamState = createCompilerState();
-      bvOnParamState.paramIndex = bvParams.length;
-      const bvCtx = {
-        rootTable,
-        aliases: /* @__PURE__ */ new Map(),
-        paramState: bvOnParamState,
-        naming,
-        outerTable: alias,
-        ...schemaName !== void 0 && { schemaName },
-        ...model !== void 0 && { model },
-        compileSubquery: () => {
-          throw new Error(
-            "Subquery in BatchValues JOIN ON condition is not supported."
-          );
-        }
-      };
-      const onNode = compileWhereIntent(intent.on, bvCtx);
-      const allBvParams = [
-        ...bvParams,
-        ...bvOnParamState.parameters
-      ];
-      results.push({
-        type: "join",
-        targetTable: alias,
-        alias,
-        joinType: intent.type,
-        joinRarg: rangeFunction,
-        joinOnNode: onNode,
-        // batchValuesParams are spliced into this.state.parameters BEFORE
-        // other params in compiler.ts, so $1/$2/... refs align correctly.
-        batchValuesParams: allBvParams
-      });
-    } else {
-      const paramState = createCompilerState();
-      const tableAlias = intent.alias ?? intent.table;
-      const tableAliasMap = /* @__PURE__ */ new Map();
-      tableAliasMap.set(rootTable, rootTable);
-      if (tableAlias !== rootTable) {
-        tableAliasMap.set(tableAlias, intent.table);
-      }
-      const ctx = {
-        rootTable,
-        aliases: tableAliasMap,
-        paramState,
-        naming,
-        // outerTable = tableAlias so FieldRef(scope:'outer') resolves to the
-        // joined alias (e.g. 'e2' in self-join ON conditions).
-        outerTable: tableAlias,
-        ...schemaName !== void 0 && { schemaName },
-        ...model !== void 0 && { model },
-        compileSubquery: () => {
-          throw new Error("Subquery in JOIN ON condition is not supported.");
-        }
-      };
-      const onNode = compileWhereIntent(intent.on, ctx);
-      const joinedRangeVar = rangeVar(
-        intent.table,
-        tableAlias,
-        schemaName,
-        naming
-      );
-      results.push({
-        type: "join",
-        targetTable: intent.table,
-        alias: tableAlias,
-        joinType: intent.type,
-        joinRarg: joinedRangeVar,
-        joinOnNode: onNode
-      });
-    }
+  if (model === void 0) {
+    throw new Error(
+      `${operation} with sourceQuery requires a model to emit the source CTE for '${sourceName}'.`
+    );
   }
-  return results;
+  const sourcePlan = planFn(sourceQuery, model, {
+    dialectCapabilities: deps.dialectCapabilities ?? POSTGRESQL_CAPABILITIES
+  });
+  return compileSelect(sourcePlan, options, deps);
 }
-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 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 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 } }]);
-    }
+function resolveMutationExistsForeignKey(foreignKey, relationName) {
+  if (typeof foreignKey === "string") return foreignKey;
+  if (!Array.isArray(foreignKey)) return void 0;
+  if (foreignKey.length > 1) {
+    throw new Error(
+      `Mutation exists()/notExists() guards do not support composite foreignKey relations yet: relation '${relationName}' has foreignKey ${JSON.stringify(foreignKey)}. Composite FK correlation is tracked by #179.`
+    );
+  }
+  return foreignKey[0];
+}
+function resolveExistsRelation(sourceTable, relation, model) {
+  if (!model) return { targetTable: relation };
+  const relationName = `${sourceTable}.${relation}`;
+  const rel = model.getRelation(relationName);
+  if (!rel) return { targetTable: relation };
+  const targetTable = rel.target;
+  if (rel.type === "belongsTo") {
+    const fk2 = resolveMutationExistsForeignKey(rel.foreignKey, relationName);
+    return {
+      targetTable,
+      ...fk2 !== void 0 && { sourceColumn: fk2 },
+      targetColumn: "id"
+    };
   }
-  return map;
+  const fk = resolveMutationExistsForeignKey(rel.foreignKey, relationName);
+  return {
+    targetTable,
+    sourceColumn: rel.sourceKey ?? "id",
+    ...fk !== void 0 && { targetColumn: fk }
+  };
 }
-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;
-        }
-      }
-    }
+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 (!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(", ")}`
-          );
-        }
-      }
-    }
+  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);
+  const nestedWhere = w.where;
+  const enrichedNestedWhere = nestedWhere !== void 0 ? resolveExistsIntent(nestedWhere, resolved.targetTable, deps) : void 0;
+  if (resolved.targetTable === relation && !resolved.sourceColumn && !resolved.targetColumn && enrichedNestedWhere === nestedWhere) {
+    return where;
   }
+  return {
+    ...w,
+    targetTable: resolved.targetTable,
+    ...resolved.sourceColumn !== void 0 && {
+      sourceColumn: resolved.sourceColumn
+    },
+    ...resolved.targetColumn !== void 0 && {
+      targetColumn: resolved.targetColumn
+    },
+    ...enrichedNestedWhere !== void 0 && { where: enrichedNestedWhere }
+  };
 }
-function applyJoinHydrationPrefixes(decisions) {
-  const usages = [];
-  for (const d of decisions) {
-    if (d.type !== "includeStrategy" || d.choice !== "join" || !d.relationName) {
-      continue;
+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;
     }
-    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;
+  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 },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    compileSubquery: (sqIntent, paramOffset) => buildSubqueryFromIntent(
+      sqIntent,
+      paramOffset,
+      deps.naming,
+      schemaName,
+      "rawExists",
+      deps.bindingNames,
+      deps.dialectCapabilities
+    )
+  };
+  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.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    ...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 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 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 },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    ...bindingNames !== void 0 && { bindingNames },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  const resolvedWhere = intent.where ? resolveExistsIntent(intent.where, intent.source, deps) : void 0;
+  const config = {
+    targetTable: intent.table,
+    sourceTable: intent.source,
+    ...intent.columns && { columns: [...intent.columns] },
+    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
+    ...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 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 },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    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.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    ...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 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 resolvedWhere = resolveExistsIntent(intent.where, intent.table, deps);
+    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 },
+      ...deps.dialectCapabilities !== void 0 && {
+        dialectCapabilities: deps.dialectCapabilities
+      },
+      compileSubquery: (sqIntent, paramOffset) => buildSubqueryFromIntent(
+        sqIntent,
+        paramOffset,
+        deps.naming,
+        schemaName,
+        "rawExists",
+        deps.bindingNames,
+        deps.dialectCapabilities
+      )
+    };
+    whereGuard = compileWhereIntent(resolvedWhere, 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 },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    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 },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    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
-    );
-  } else {
-    simplifiedPlan = {
-      rootTable: plan.rootTable,
-      decisions: bridgeLegacyDecisions(plan.decisions),
-      ...schemaName ? { schema: schemaName } : {}
-    };
   }
-  const result = compilePlan(simplifiedPlan, compilerOptions);
-  return {
-    sql: result.sql,
-    parameters: result.parameters
+  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
+      )
+    }
   };
-}
-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 maxBatchSize = options?.maxBatchSize;
+  if (maxBatchSize !== void 0 && values.length > maxBatchSize) {
+    throw new InvalidOperationError3(
+      "upsert",
+      `Batch size ${values.length} exceeds maxBatchSize ${maxBatchSize}`
     );
-    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;
+  }
+  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 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 },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
+    ...bindingNames !== void 0 && { bindingNames },
+    maxRecursiveDepth: 100
+  };
+  const state = createCompilerState();
+  const resolvedWhere = intent.where ? resolveExistsIntent(intent.where, intent.source, deps) : void 0;
+  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 },
+    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
+    ...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
@@ -16859,6 +17247,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();
@@ -17025,9 +17414,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 });
@@ -17149,14 +17538,257 @@ function mapFetchDirection(direction) {
 
 // src/pgsql-adapter.ts
 init_validate();
-function renumberSqlParams(sql, offset) {
+var MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS = 32e3;
+function renumberSqlParams2(sql, offset) {
   if (offset === 0) return sql;
   return sql.replace(/\$(\d+)/g, (_match, num) => {
     return `$${Number.parseInt(num, 10) + 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);
+  return !("intent" in input) && ("query" in input || "cteQuery" in input || "mutation" in input || "setOperation" in input || "bindings" in input || "mutationBindings" in input || "runtimeBindings" 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;
+}
+function orderedNqlBindingNames(bundle) {
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of bundle.bindings?.keys() ?? []) {
+    names.push(name);
+    seen.add(name);
+  }
+  for (const name of bundle.runtimeBindings?.keys() ?? []) {
+    if (!seen.has(name)) {
+      names.push(name);
+      seen.add(name);
+    }
+  }
+  return names;
+}
+function mapRuntimeBindingColumnType(type) {
+  switch (type) {
+    case "string":
+      return "text";
+    case "text":
+      return "text";
+    case "number":
+    case "integer":
+      return "integer";
+    case "bigint":
+      return "bigint";
+    case "decimal":
+      return "numeric";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "date";
+    case "time":
+      return "time";
+    case "datetime":
+    case "timestamp":
+      return "timestamptz";
+    case "json":
+    case "jsonb":
+      return "jsonb";
+    case "uuid":
+      return "uuid";
+    case "daterange":
+      return "daterange";
+    case "tsrange":
+      return "tsrange";
+    case "tstzrange":
+      return "tstzrange";
+    case "int4range":
+      return "int4range";
+    case "int8range":
+      return "int8range";
+    case "numrange":
+      return "numrange";
+    default:
+      return void 0;
+  }
+}
+function findRuntimeBindingSourceTable(model, sourceTable) {
+  return model.getTable(sourceTable) ?? [...model.tables.values()].find((table) => table.name === sourceTable);
+}
+function resolveRuntimeBindingColumnType(bindingName, sourceTable, columnName) {
+  const column = sourceTable.columns.find(
+    (candidate) => candidate.name === columnName
+  );
+  if (column === void 0) {
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot resolve projected column '${columnName}' on source mutation table '${sourceTable.name}'.`
+    );
+  }
+  const dbType = column.originalDbType?.trim() || mapRuntimeBindingColumnType(column.type);
+  if (dbType === void 0 || dbType.trim() === "") {
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${columnName}' on source mutation table '${sourceTable.name}'.`
+    );
+  }
+  const typeName = dbType.trim();
+  try {
+    validateTypeName4(typeName);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${columnName}': ${reason}`
+    );
+  }
+  return typeName;
+}
+function resolveRuntimeBindingColumnTypes(name, binding, model, sourceTableName) {
+  if (model === void 0) {
+    throw new Error(
+      `NQL runtime binding '${name}' cannot materialize non-empty rows because no model is available for source-table column type resolution.`
+    );
+  }
+  const sourceTable = findRuntimeBindingSourceTable(model, sourceTableName);
+  if (sourceTable === void 0) {
+    throw new Error(
+      `NQL runtime binding '${name}' cannot resolve source mutation table '${sourceTableName}' in the model.`
+    );
+  }
+  return binding.columns.map(
+    (column) => resolveRuntimeBindingColumnType(name, sourceTable, column)
+  );
+}
+function assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset) {
+  const valueParameterCount = binding.rows.length * binding.columns.length;
+  if (valueParameterCount <= MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS && parameterOffset + valueParameterCount <= MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS) {
+    return;
+  }
+  const totalParameterCount = parameterOffset + valueParameterCount;
+  throw new Error(
+    `NQL runtime binding '${name}' would materialize ${valueParameterCount} VALUES parameters; limit is ${MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS}. Current parameter offset is ${parameterOffset}, which would make ${totalParameterCount} total parameters before compiling the final statement.`
+  );
+}
+function compileNqlRuntimeBindingCte(name, binding, naming, parameterOffset, sourceTable, schemaName, model) {
+  if (binding.columns.length === 0) {
+    throw new Error(
+      `NQL runtime binding '${name}' cannot be materialized without projected columns.`
+    );
+  }
+  const cteName = quoteIdent2(emittedBindName(name, naming), "alias");
+  const columnSql = binding.columns.map((column) => quoteIdent2(naming.toDatabase(column), "column")).join(", ");
+  if (sourceTable === void 0) {
+    throw new Error(
+      `NQL runtime binding '${name}' cannot materialize a typed relation because its source mutation table is unavailable.`
+    );
+  }
+  const projectedColumns = binding.columns.map((column) => quoteIdent2(naming.toDatabase(column), "column")).join(", ");
+  const sourceAnchorSql = `SELECT ${projectedColumns} FROM ${qualifyTableIdent(sourceTable, schemaName, naming)} WHERE false`;
+  if (binding.rows.length === 0) {
+    return {
+      cte: `${cteName} (${columnSql}) as (${sourceAnchorSql})`,
+      parameters: []
+    };
+  }
+  assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset);
+  const columnTypes = resolveRuntimeBindingColumnTypes(
+    name,
+    binding,
+    model,
+    sourceTable
+  );
+  const parameters = [];
+  let nextParam = parameterOffset + 1;
+  const valuesSql = binding.rows.map((row) => {
+    const placeholders = binding.columns.map((column, columnIndex) => {
+      parameters.push(row[column]);
+      return `$${nextParam++}::${columnTypes[columnIndex]}`;
+    });
+    return `(${placeholders.join(", ")})`;
+  }).join(", ");
+  return {
+    cte: `${cteName} (${columnSql}) as (${sourceAnchorSql} UNION ALL VALUES ${valuesSql})`,
+    parameters
+  };
+}
+function createNqlBindingSelectPlan(query) {
+  return {
+    rootTable: query.from,
+    decisions: [],
+    warnings: [],
+    ctes: [],
+    intent: query,
+    metadata: {
+      planningTimeMs: 0,
+      relationsAnalyzed: 0,
+      isAmbiguous: false
+    }
+  };
 }
 var PgsqlAdapter = class _PgsqlAdapter {
   pool;
@@ -17224,17 +17856,20 @@ 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,
+      dialectCapabilities: options?.dialectCapabilities ?? this.dialectCapabilities,
       defaultPk: this.defaultPk,
-      deriveFk: this.deriveFk
+      deriveFk: this.deriveFk,
+      ...bindingNames !== void 0 && { bindingNames }
     };
   }
   requireNqlCompileModel(options) {
@@ -17246,7 +17881,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.");
@@ -17256,84 +17908,140 @@ 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 model = this.requireNqlCompileModel(options);
-      const planReport = planFn(bundle.query, model, {
-        dialectCapabilities: this.dialectCapabilities
+      const deps = this.buildCompileDeps(options, bindingNames);
+      const queryFromBinding = hasBindingName(
+        bindingNames,
+        bundle.query.from,
+        deps.naming
+      );
+      const planReport = queryFromBinding ? createNqlBindingSelectPlan(bundle.query) : planFn2(bundle.query, this.requireNqlCompileModel(options), {
+        dialectCapabilities: options?.dialectCapabilities ?? this.dialectCapabilities
       });
-      return compileSelect(
-        planReport,
-        options,
-        this.buildCompileDeps(options)
+      return guardCompiledQuery(
+        compileSelect(planReport, options, deps),
+        "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 = [];
-    for (const [name, queryIntent] of bundle.bindings ?? []) {
-      const cteName = quoteIdent2(name, "alias");
+    const deps = this.buildCompileDeps(options);
+    const { naming } = deps;
+    const bindingNamesInOrder = orderedNqlBindingNames(bundle);
+    const duplicateEmittedBinding = bindingNamesInOrder.length > 0 ? findDuplicateEmittedNqlBindingName(bindingNamesInOrder, 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 = bindingNamesInOrder.length > 0 ? new Set(
+      bindingNamesInOrder.map((name) => emittedBindName(name, naming))
+    ) : void 0;
+    this.assertNqlBindingNamesDisjointFromTables(bindingNames, options);
+    for (const name of bindingNamesInOrder) {
+      const runtimeBinding = bundle.runtimeBindings?.get(name);
+      if (runtimeBinding !== void 0) {
+        const compiledRuntimeBinding = compileNqlRuntimeBindingCte(
+          name,
+          runtimeBinding,
+          naming,
+          parameters.length,
+          bundle.mutationBindings?.get(name)?.table,
+          deps.schemaName,
+          deps.model
+        );
+        ctes.push(compiledRuntimeBinding.cte);
+        parameters.push(...compiledRuntimeBinding.parameters);
+        continue;
+      }
+      const queryIntent = bundle.bindings?.get(name);
+      if (queryIntent === void 0) {
+        throw new Error(
+          `NQL binding '${name}' has no query intent or runtime rows to materialize.`
+        );
+      }
+      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);
     }
@@ -17346,14 +18054,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.
@@ -17373,7 +18088,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.
@@ -17392,21 +18107,28 @@ var PgsqlAdapter = class _PgsqlAdapter {
   // =========================================================================
   /**
    * Compile a plan to executable SQL.
+   *
+   * When passed a direct `CompiledNqlQuery`, the adapter trusts that the bundle
+   * has already been semantically validated by the NQL compiler. This method
+   * still performs adapter-owned SQL safety checks for emitted binding names
+   * before CTE emission.
    */
   compile(plan, options) {
     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"
     );
   }
   /**
@@ -17419,11 +18141,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"
     );
   }
   /**
@@ -17438,10 +18163,12 @@ var PgsqlAdapter = class _PgsqlAdapter {
   compileSelectExpression(expr) {
     const naming = this.naming;
     const schemaName = this.schemaName;
+    const dialectCapabilities = this.dialectCapabilities;
     const state = createCompilerState();
     const ctx = {
       naming,
       ...schemaName !== void 0 && { schema: schemaName },
+      dialectCapabilities,
       rootTable: "",
       maxRecursiveDepth: 100,
       // Wire compileSubquery so that SubqueryExpressionIntent nested inside
@@ -17451,7 +18178,8 @@ var PgsqlAdapter = class _PgsqlAdapter {
       compileSubquery(query, paramOffset) {
         const innerCompiler = new PlanCompiler({
           naming,
-          ...schemaName !== void 0 && { schema: schemaName }
+          ...schemaName !== void 0 && { schema: schemaName },
+          dialectCapabilities
         });
         const innerPlan = {
           rootTable: query.from,
@@ -17467,7 +18195,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.
@@ -17477,24 +18208,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).
@@ -17506,33 +18242,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"
     );
   }
   /**
@@ -17540,11 +18280,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"
     );
   }
   /**
@@ -17555,18 +18298,45 @@ 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);
-    const result = compileSetOperation(intent, compileFn);
-    return {
-      sql: result.sql,
-      parameters: result.parameters
+    return guardCompiledQuery(
+      this.compileSetOperationWithBindings(intent, model, options),
+      "set operation"
+    );
+  }
+  compileSetOperationWithBindings(intent, model, options, bindingNames) {
+    const compileFn = (query) => {
+      const leafOptions = {
+        ...options,
+        model
+      };
+      const deps = this.buildCompileDeps(leafOptions, bindingNames);
+      const queryFromBinding = hasBindingName(
+        bindingNames,
+        query.from,
+        deps.naming
+      );
+      const planReport = queryFromBinding ? createNqlBindingSelectPlan(query) : planFn2(query, model, {
+        dialectCapabilities: options?.dialectCapabilities ?? this.dialectCapabilities
+      });
+      return compileSelect(planReport, leafOptions, deps);
     };
+    const result = compileSetOperation(intent, compileFn);
+    return guardCompiledQuery(
+      {
+        sql: result.sql,
+        parameters: result.parameters
+      },
+      "set operation"
+    );
   }
   /**
    * Create a dump for observability.