@dbsp/adapter-pgsql 1.3.0 → 1.5.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 = [];
@@ -1421,6 +1457,10 @@ var init_custom = __esm({
 });
 
 // src/select-expression-handlers.ts
+import {
+  getTrustedNqlRelationFilterFields,
+  markNqlTrustedRelationFilter
+} from "@dbsp/types/internal";
 function handleColumnExpression(expr, rootTable, decisions) {
   const decision = {
     type: "select",
@@ -1549,14 +1589,18 @@ function handleCaseExpression(expr, rootTable, decisions, _applyFilter, convertC
   decisions.push(decision);
 }
 function handleRelationColumnExpression(expr, rootTable, decisions) {
+  const trusted = getTrustedNqlRelationFilterFields(expr);
+  const trustedRelation = typeof trusted?.relation === "string" ? trusted.relation : trusted?.relation.join(".");
   const decision = {
     type: "selectRelationColumn",
-    relation: expr.relation,
-    column: expr.column ?? "*",
+    relation: trustedRelation ?? expr.relation,
+    column: trusted?.selectedColumn ?? (expr.column ?? "*"),
     table: rootTable
   };
   if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
+  decisions.push(
+    trusted?.selectedColumn !== void 0 ? markNqlTrustedRelationFilter(decision, trusted) : decision
+  );
 }
 function handleArithmeticExpression(expr, rootTable, decisions) {
   const decision = {
@@ -1654,6 +1698,9 @@ var init_select_expression_handlers = __esm({
 
 // src/intent-to-decisions.ts
 import { isParamIntent } from "@dbsp/types";
+import {
+  getTrustedNqlRelationFilterFields as getTrustedNqlRelationFilterFields2
+} from "@dbsp/types/internal";
 function intentToDecisions(intent, rootTable) {
   const decisions = [];
   if (intent.select) {
@@ -2039,10 +2086,29 @@ function convertNot(cond, rootTable) {
   if (!subDecision) return null;
   return { type: "whereNot", conditions: [subDecision] };
 }
+function formatRelationName(relation) {
+  return typeof relation === "string" ? relation : relation.join(".");
+}
 function convertExistsLike(cond, operator) {
-  const targetTable = cond.relation;
+  const rawRelation = cond.relation;
+  const preResolved = getTrustedNqlRelationFilterFields2(cond);
+  const trustedRelation = preResolved?.relation;
+  const relationName = trustedRelation !== void 0 ? formatRelationName(trustedRelation) : formatRelationName(rawRelation);
+  const targetTable = preResolved?.targetTable ?? rawRelation;
   const subDecisions = cond.where ? convertWhere(cond.where, targetTable) : [];
-  const base = { type: "where", operator, targetTable };
+  const isPreResolved = preResolved !== void 0;
+  const base = {
+    type: "where",
+    operator,
+    targetTable,
+    ...preResolved !== void 0 && {
+      sourceColumn: preResolved.sourceColumn
+    },
+    ...preResolved !== void 0 && {
+      targetColumn: preResolved.targetColumn
+    },
+    ...isPreResolved && { relationName }
+  };
   return subDecisions.length > 0 ? { ...base, conditions: subDecisions } : base;
 }
 function convertSubquery(cond) {
@@ -2813,6 +2879,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 +2941,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 +2954,6 @@ var init_utils = __esm({
     init_ast_helpers();
     init_param_intent();
     init_param_ref();
-    init_validate();
     init_types();
     init_param_intent();
   }
@@ -2915,6 +2985,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 +2993,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 +3193,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 +3239,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 +3298,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 +3324,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 +3395,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 +3425,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 +3454,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 +3472,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 +3502,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 +3526,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 +3708,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 +3721,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");
@@ -3651,28 +3773,8 @@ var init_range = __esm({
   }
 });
 
-// src/binding-registry.ts
-function emittedBindName(name, naming) {
-  return naming.toDatabase(name);
-}
-function hasBindingName(bindingNames, name, naming) {
-  return bindingNames?.has(emittedBindName(name, naming)) ?? false;
-}
-function schemaForFromName(schemaName, fromName, bindingNames, naming) {
-  return hasBindingName(bindingNames, fromName, naming) ? void 0 : schemaName;
-}
-function withBindingName(bindingNames, name, naming) {
-  const next = new Set(bindingNames ?? []);
-  next.add(emittedBindName(name, naming));
-  return next;
-}
-var init_binding_registry = __esm({
-  "src/binding-registry.ts"() {
-    "use strict";
-  }
-});
-
 // src/compile-where.ts
+import { getTrustedNqlRelationFilterFields as getTrustedNqlRelationFilterFields3 } from "@dbsp/types/internal";
 function toHandlerContext(ctx) {
   return {
     naming: ctx.naming,
@@ -3680,12 +3782,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", bindingNames) {
+function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, schemaName, use = "rawExists", bindingNames, dialectCapabilities) {
   assertNoUnsupportedSubqueryModifiers(intent, use);
   if (intent.where && containsOuterRef(intent.where)) {
     throw new Error(
@@ -3751,6 +3856,8 @@ 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(
@@ -3861,11 +3968,16 @@ function handleSubqueryIntent(intent, ctx, _handlerCtx) {
 }
 function handleRelationFilterIntent(intent, ctx) {
   const rf = intent;
-  const hops = Array.isArray(rf.relation) ? rf.relation : [rf.relation];
+  const preResolved = getTrustedNqlRelationFilterFields3(rf);
+  const relationPath = preResolved?.relation ?? rf.relation;
+  const hops = Array.isArray(relationPath) ? [...relationPath] : [relationPath];
   const existsKind = rf.mode === "none" || rf.mode === "every" ? "notExists" : "exists";
   const rfWhere = rf.where;
   const isVacuousEvery = rf.mode === "every" && (!rfWhere || typeof rfWhere === "object" && rfWhere.kind === "and" && Array.isArray(rfWhere.conditions) && rfWhere.conditions.length === 0);
   if (isVacuousEvery) {
+    if (preResolved) {
+      return { A_Const: { boolval: { boolval: true } } };
+    }
     if (hops.length <= 1) {
       const relation = hops[0] ?? rf.relation;
       if (!ctx.model) {
@@ -3901,6 +4013,19 @@ function handleRelationFilterIntent(intent, ctx) {
   const innermostWhere = rf.mode === "every" ? { kind: "not", condition: rf.where } : rf.where;
   if (hops.length <= 1) {
     const relation = hops[0] ?? rf.relation;
+    if (preResolved) {
+      return compileWhereIntent(
+        {
+          kind: existsKind,
+          relation,
+          targetTable: preResolved.targetTable,
+          sourceColumn: preResolved.sourceColumn,
+          targetColumn: preResolved.targetColumn,
+          where: innermostWhere
+        },
+        ctx
+      );
+    }
     const resolvedRelation = ctx.model?.getRelation(
       `${ctx.rootTable}.${relation}`
     );
@@ -4175,7 +4300,8 @@ var init_raw_exists = __esm({
           ctx.naming,
           ctx.schema,
           "rawExists",
-          ctx.bindingNames
+          ctx.bindingNames,
+          ctx.dialectCapabilities
         );
         if (innerParams) {
           for (const p of innerParams) {
@@ -5984,11 +6110,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");
@@ -6016,6 +6148,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");
@@ -7087,13 +7224,18 @@ 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";
+import {
+  getNqlBindingRefName,
+  getTrustedNqlRelationFilterFields as getTrustedNqlRelationFilterFields4,
+  isNqlBindingRef
+} from "@dbsp/types/internal";
 
 // src/pgsql-deparser.ts
 function deparse(node) {
@@ -8148,6 +8290,7 @@ function deparseQuoted(ast) {
 }
 
 // src/compiler.ts
+init_dialect_capabilities();
 init_case_value();
 init_custom();
 init_expression();
@@ -8194,6 +8337,12 @@ function assertNqlSelectWindowFunctionAllowed(functionName) {
   }
 }
 function mapToHandlerDecision(pd, rootTable, defaultPk, deriveFk) {
+  const derivedFkColumns = deriveFkColumns(
+    pd,
+    pd.sourceTable ?? rootTable,
+    defaultPk,
+    deriveFk
+  );
   return {
     type: pd.type,
     table: pd.table,
@@ -8204,7 +8353,8 @@ function mapToHandlerDecision(pd, rootTable, defaultPk, deriveFk) {
     paramIndex: pd.paramIndex,
     direction: pd.direction,
     joinType: pd.joinType,
-    ...deriveFkColumns(pd, pd.sourceTable ?? rootTable, defaultPk, deriveFk),
+    sourceColumn: pd.sourceColumn ?? derivedFkColumns.sourceColumn,
+    targetColumn: pd.targetColumn ?? derivedFkColumns.targetColumn,
     targetTable: pd.targetTable,
     function: pd.function,
     args: pd.args,
@@ -8380,6 +8530,7 @@ var PlanCompiler = class _PlanCompiler {
   defaultPk;
   deriveFk;
   model;
+  dialectCapabilities;
   bindingNames;
   /** Mutable state shared with extracted condition/value compilation functions */
   state = {
@@ -8397,6 +8548,8 @@ var PlanCompiler = class _PlanCompiler {
   rawJoins = [];
   /** CTE nodes from include handlers (e.g., CTE strategy) */
   pendingCtes = [];
+  /** Local aliases for binding relation-column scalar subqueries. */
+  bindingRelationColumnSubqueryIndex = 0;
   /**
    * Maps relation-dotted include path → JOIN alias for multi-hop FK resolution.
    * Populated as join decisions are compiled so later hops can find the
@@ -8415,8 +8568,25 @@ 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() {
     return {
@@ -8427,6 +8597,9 @@ 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 }
     };
@@ -8737,6 +8910,9 @@ 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),
@@ -8753,18 +8929,66 @@ var PlanCompiler = class _PlanCompiler {
       joins: []
     };
   }
-  compileExpressionSubquery(query, paramOffset) {
-    const innerCompiler = new _PlanCompiler({
-      naming: this.naming,
-      ...this.schema !== void 0 && {
-        schema: this.schema
-      },
-      defaultPkColumnName: this.defaultPk,
-      deriveFkColumnName: this.deriveFk,
-      ...this.bindingNames !== void 0 && {
-        bindingNames: this.bindingNames
+  schemaForRangeVar(plan, table) {
+    return schemaForFromName(
+      plan.schema ?? this.schema,
+      table,
+      this.bindingNames,
+      this.naming
+    );
+  }
+  isNqlBindingRoot(plan) {
+    return hasBindingName(this.bindingNames, plan.rootTable, this.naming);
+  }
+  compileBindingRelationColumnSubquery(fields, plan) {
+    if (fields.selectedColumn === void 0) {
+      throw new Error(
+        `NQL binding relation-column proof for '${plan.rootTable}' is missing selectedColumn.`
+      );
+    }
+    if (fields.cardinality !== "one") {
+      throw new Error(
+        `NQL binding relation-column proof for '${plan.rootTable}' is not scalar (cardinality: ${fields.cardinality ?? "unknown"}).`
+      );
+    }
+    const relatedAlias = `rc_${this.bindingRelationColumnSubqueryIndex++}`;
+    const relatedTable = rangeVar(
+      fields.targetTable,
+      relatedAlias,
+      this.schemaForRangeVar(plan, fields.targetTable),
+      this.naming
+    );
+    const relatedColumn = columnRef(
+      fields.selectedColumn,
+      relatedAlias,
+      void 0,
+      this.naming
+    );
+    const relatedJoinColumn = columnRef(
+      fields.targetColumn,
+      relatedAlias,
+      void 0,
+      this.naming
+    );
+    const bindingJoinColumn = columnRef(
+      fields.sourceColumn,
+      plan.rootTable,
+      void 0,
+      this.naming
+    );
+    return {
+      SubLink: {
+        subLinkType: "EXPR_SUBLINK",
+        subselect: selectStmt({
+          targetList: [{ ResTarget: { val: relatedColumn } }],
+          from: [relatedTable],
+          where: eqExpr(relatedJoinColumn, bindingJoinColumn)
+        })
       }
-    });
+    };
+  }
+  compileExpressionSubquery(query, paramOffset) {
+    const innerCompiler = new _PlanCompiler(this.childCompilerOptions());
     const innerPlan = {
       rootTable: query.from,
       decisions: intentToDecisions(query, query.from)
@@ -9104,24 +9328,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();
@@ -9157,6 +9364,27 @@ var PlanCompiler = class _PlanCompiler {
       case "selectRelationColumn":
       case "selectPseudoColumn":
       case "selectArithmetic": {
+        if (decision.type === "selectRelationColumn") {
+          const trusted = getTrustedNqlRelationFilterFields4(decision);
+          if (trusted?.selectedColumn !== void 0) {
+            const node2 = this.compileBindingRelationColumnSubquery(
+              trusted,
+              plan
+            );
+            targetList.push({
+              ResTarget: {
+                val: node2,
+                ...decision.alias ? { name: this.naming.toDatabase(decision.alias) } : {}
+              }
+            });
+            break;
+          }
+          if (this.isNqlBindingRoot(plan)) {
+            throw new Error(
+              `NQL binding-final query '${plan.rootTable}' cannot select relation column '${decision.relation ?? "unknown"}.${decision.column ?? "unknown"}' without a trusted compiler proof.`
+            );
+          }
+        }
         ensureExpressionHandlersRegistered();
         const exprType = decision.type === "selectRelationColumn" ? "relationColumn" : decision.type === "selectPseudoColumn" ? "pseudoColumn" : "arithmetic";
         const handler = getExpressionHandler(exprType);
@@ -9307,13 +9535,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);
@@ -9322,7 +9550,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;
@@ -9347,7 +9575,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
       )
     ];
@@ -9494,6 +9722,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 = {
@@ -9503,7 +9743,7 @@ var PlanCompiler = class _PlanCompiler {
             rangeVar(
               plan.rootTable,
               void 0,
-              plan.schema ?? this.schema,
+              this.schemaForRangeVar(plan, plan.rootTable),
               this.naming
             )
           ]
@@ -9883,13 +10123,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(
@@ -13939,7 +14179,11 @@ init_naming_plugin();
 init_param_ref();
 
 // src/pgsql-adapter.ts
-import { POSTGRESQL_CAPABILITIES as POSTGRESQL_CAPABILITIES2, plan as planFn2 } 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
@@ -14136,6 +14380,7 @@ import {
 // 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();
@@ -15174,7 +15419,13 @@ function compileJoinIntents(joins, rootTable, schemaName, deps) {
         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."
@@ -15214,7 +15465,13 @@ function compileJoinIntents(joins, rootTable, schemaName, deps) {
         // 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.");
         }
@@ -15223,7 +15480,7 @@ function compileJoinIntents(joins, rootTable, schemaName, deps) {
       const joinedRangeVar = rangeVar(
         intent.table,
         tableAlias,
-        schemaName,
+        schemaForFromName(schemaName, intent.table, deps.bindingNames, naming),
         naming
       );
       results.push({
@@ -15386,6 +15643,9 @@ function compileSelect(plan, options, deps) {
     ...deps.bindingNames !== void 0 && {
       bindingNames: deps.bindingNames
     },
+    ...deps.dialectCapabilities !== void 0 && {
+      dialectCapabilities: deps.dialectCapabilities
+    },
     ...resolvedModelForCompiler != null && {
       model: resolvedModelForCompiler
     }
@@ -15545,7 +15805,7 @@ function compileSourceQueryCte(operation, sourceName, sourceQuery, options, deps
     );
   }
   const sourcePlan = planFn(sourceQuery, model, {
-    dialectCapabilities: POSTGRESQL_CAPABILITIES
+    dialectCapabilities: deps.dialectCapabilities ?? POSTGRESQL_CAPABILITIES
   });
   return compileSelect(sourcePlan, options, deps);
 }
@@ -15560,20 +15820,31 @@ function prependSourceCte(sql, parameters, sourceName, sourceCte, naming) {
     parameters: [...sourceCte.parameters, ...parameters]
   };
 }
+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 rel = model.getRelation(`${sourceTable}.${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 = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
+    const fk2 = resolveMutationExistsForeignKey(rel.foreignKey, relationName);
     return {
       targetTable,
       ...fk2 !== void 0 && { sourceColumn: fk2 },
       targetColumn: "id"
     };
   }
-  const fk = typeof rel.foreignKey === "string" ? rel.foreignKey : rel.foreignKey?.[0];
+  const fk = resolveMutationExistsForeignKey(rel.foreignKey, relationName);
   return {
     targetTable,
     sourceColumn: rel.sourceKey ?? "id",
@@ -15601,7 +15872,11 @@ function resolveExistsIntent(where, sourceTable, deps) {
   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;
+  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,
@@ -15610,7 +15885,8 @@ function resolveExistsIntent(where, sourceTable, deps) {
     },
     ...resolved.targetColumn !== void 0 && {
       targetColumn: resolved.targetColumn
-    }
+    },
+    ...enrichedNestedWhere !== void 0 && { where: enrichedNestedWhere }
   };
 }
 function getColumnTypes(tableName, columns, deps) {
@@ -15636,13 +15912,17 @@ function compileUpsertActionWhere(where, table, state, deps, schemaName) {
     ...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.bindingNames,
+      deps.dialectCapabilities
     )
   };
   return compileWhereIntent(where, whereCtx);
@@ -15653,6 +15933,9 @@ function compileInsert2(intent, options, deps) {
     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
   };
@@ -15699,15 +15982,19 @@ function compileInsertFrom2(intent, options, deps) {
     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] },
-    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
+    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
     ...intent.limit !== void 0 && { limit: intent.limit },
     ...intent.returning && { returning: [...intent.returning] }
   };
@@ -15730,6 +16017,9 @@ function compileUpdate2(intent, options, deps) {
     ...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();
@@ -15759,6 +16049,9 @@ function compileBatchUpdate(intent, _options, deps) {
     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
   };
@@ -15789,6 +16082,7 @@ function compileBatchUpdate(intent, _options, deps) {
   })) : void 0;
   let whereGuard;
   if (intent.where) {
+    const resolvedWhere = resolveExistsIntent(intent.where, intent.table, deps);
     const whereCtx = {
       rootTable: intent.table,
       aliases: /* @__PURE__ */ new Map(),
@@ -15799,16 +16093,20 @@ function compileBatchUpdate(intent, _options, deps) {
         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.bindingNames,
+        deps.dialectCapabilities
       )
     };
-    whereGuard = compileWhereIntent(intent.where, whereCtx);
+    whereGuard = compileWhereIntent(resolvedWhere, whereCtx);
   }
   const config = {
     table: intent.table,
@@ -15835,6 +16133,9 @@ function compileDelete2(intent, options, deps) {
     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 }
   };
@@ -15860,6 +16161,9 @@ function compileUpsert2(intent, options, deps) {
     ...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 state = createCompilerState();
@@ -15953,10 +16257,14 @@ function compileUpsertFrom2(intent, options, deps) {
     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];
@@ -15971,7 +16279,7 @@ function compileUpsertFrom2(intent, options, deps) {
     sourceTable: intent.source,
     conflictColumns: [...intent.conflictColumns],
     ...columns && { columns },
-    ...intent.where && { where: [whereIntentAsDecision(intent.where)] },
+    ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
     ...intent.limit !== void 0 && { limit: intent.limit },
     ...intent.returning && { returning: [...intent.returning] }
   };
@@ -17363,6 +17671,7 @@ function mapFetchDirection(direction) {
 
 // src/pgsql-adapter.ts
 init_validate();
+var MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS = 32e3;
 function renumberSqlParams2(sql, offset) {
   if (offset === 0) return sql;
   return sql.replace(/\$(\d+)/g, (_match, num) => {
@@ -17370,7 +17679,7 @@ function renumberSqlParams2(sql, offset) {
   });
 }
 function isCompiledNqlQuery(input) {
-  return !("intent" in input) && ("query" in input || "cteQuery" in input || "mutation" in input || "setOperation" in input || "bindings" in input || "mutationBindings" in input);
+  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)}]`;
@@ -17445,6 +17754,175 @@ function findDuplicateEmittedNqlBindingName(bindingNames, naming) {
   }
   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;
   client;
@@ -17521,6 +17999,7 @@ var PgsqlAdapter = class _PgsqlAdapter {
       // `||` (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,
       ...bindingNames !== void 0 && { bindingNames }
@@ -17601,22 +18080,17 @@ var PgsqlAdapter = class _PgsqlAdapter {
   }
   compileNqlBundleLeaf(bundle, options, bindingNames) {
     if (bundle.query !== void 0) {
-      const naming = this.buildCompileDeps(options, bindingNames).naming;
-      if (hasBindingName(bindingNames, bundle.query.from, naming)) {
-        throw new Error(
-          `NQL binding '${bundle.query.from}' cannot be used as the final FROM source yet. Use the binding from a mutation source or WHERE IN predicate, or select from a real table.`
-        );
-      }
-      const model = this.requireNqlCompileModel(options);
-      const planReport = planFn2(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 guardCompiledQuery(
-        compileSelect(
-          planReport,
-          options,
-          this.buildCompileDeps(options, bindingNames)
-        ),
+        compileSelect(planReport, options, deps),
         "NQL query"
       );
     }
@@ -17657,20 +18131,41 @@ var PgsqlAdapter = class _PgsqlAdapter {
   compileNqlBundle(bundle, options) {
     const ctes = [];
     const parameters = [];
-    const naming = this.buildCompileDeps(options).naming;
-    const duplicateEmittedBinding = bundle.bindings !== void 0 ? findDuplicateEmittedNqlBindingName(bundle.bindings.keys(), naming) : void 0;
+    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 = bundle.bindings !== void 0 ? new Set(
-      [...bundle.bindings.keys()].map(
-        (name) => emittedBindName(name, naming)
-      )
+    const bindingNames = bindingNamesInOrder.length > 0 ? new Set(
+      bindingNamesInOrder.map((name) => emittedBindName(name, naming))
     ) : void 0;
     this.assertNqlBindingNamesDisjointFromTables(bindingNames, options);
-    for (const [name, queryIntent] of bundle.bindings ?? []) {
+    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(
@@ -17745,6 +18240,11 @@ 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)) {
@@ -17796,10 +18296,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
@@ -17809,7 +18311,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,
@@ -17943,19 +18446,22 @@ var PgsqlAdapter = class _PgsqlAdapter {
     );
   }
   compileSetOperationWithBindings(intent, model, options, bindingNames) {
-    const compileFn = createLeafCompileFn(
-      {
-        dialectCapabilities: this.dialectCapabilities,
-        compile: (planReport, leafOptions) => compileSelect(
-          planReport,
-          leafOptions,
-          this.buildCompileDeps(leafOptions, bindingNames)
-        )
-      },
-      model,
-      planFn2,
-      options
-    );
+    const 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(
       {