@dbsp/adapter-pgsql 1.1.0 → 1.1.1

package/dist/index.js

@@ -94,1854 +94,2309 @@ var init_naming_plugin = __esm({
   }
 });
 
-// src/ast-helpers.ts
-import { normalizeSQL } from "@dbsp/core";
-function applyReturningList(stmt, returning) {
-  if (returning && returning.length > 0) {
-    stmt.returningList = returning;
+// src/validate.ts
+function validateIdentifier(value, type) {
+  if (!value || value.length === 0) {
+    throw new InvalidIdentifierError(value, type, "cannot be empty");
   }
-}
-function stringNode(value) {
-  return { String: { sval: value } };
-}
-function integerNode(value) {
-  return { Integer: { ival: value } };
-}
-function floatNode(value) {
-  return { Float: { fval: value } };
-}
-function booleanConstNode(value) {
-  return {
-    A_Const: {
-      boolval: { boolval: value }
+  if (value.length > 63) {
+    throw new InvalidIdentifierError(
+      value,
+      type,
+      `exceeds maximum length of 63 characters (got ${value.length})`
+    );
+  }
+  const validIdentifierPattern = /^[a-zA-Z_][a-zA-Z0-9_$]*$/;
+  if (!validIdentifierPattern.test(value)) {
+    if (/[\x00-\x1f\x7f]/.test(value)) {
+      throw new InvalidIdentifierError(
+        value,
+        type,
+        "contains control characters"
+      );
     }
-  };
-}
-function nullConstNode() {
-  return {
-    A_Const: {
-      isnull: true
+    if (/^[0-9]/.test(value)) {
+      throw new InvalidIdentifierError(
+        value,
+        type,
+        "cannot start with a digit"
+      );
     }
-  };
-}
-function columnRef(column, table, schema, naming = identityNaming) {
-  const fields = [];
-  if (schema) {
-    fields.push(stringNode(naming.toDatabase(schema)));
+    if (/[^\w$]/.test(value)) {
+      throw new InvalidIdentifierError(
+        value,
+        type,
+        "contains invalid characters (only letters, digits, underscore, and $ allowed)"
+      );
+    }
+    throw new InvalidIdentifierError(
+      value,
+      type,
+      "does not match valid identifier pattern"
+    );
   }
-  if (table) {
-    fields.push(stringNode(naming.toDatabase(table)));
+  if (value.includes("\0")) {
+    throw new InvalidIdentifierError(value, type, "contains null byte");
   }
-  fields.push(stringNode(naming.toDatabase(column)));
-  return { ColumnRef: { fields } };
 }
-function columnRefStar(table, naming = identityNaming) {
-  const fields = [];
-  if (table) {
-    fields.push(stringNode(naming.toDatabase(table)));
-  }
-  fields.push({ A_Star: {} });
-  return { ColumnRef: { fields } };
+function isReservedKeyword(value) {
+  return SQL_RESERVED_KEYWORDS.has(value.toLowerCase());
 }
-function rangeVar(table, alias, schema, naming = identityNaming) {
-  const rv = {
-    relname: naming.toDatabase(table),
-    inh: true,
-    relpersistence: "p"
-  };
-  if (schema) {
-    rv.schemaname = naming.toDatabase(schema);
-  }
-  if (alias) {
-    rv.alias = { aliasname: naming.toDatabase(alias) };
+function validateQualifiedIdentifier(schemaTable) {
+  const parts = schemaTable.split(".");
+  if (parts.length === 1) {
+    validateIdentifier(parts[0], "table");
+    return { table: parts[0] };
   }
-  return { RangeVar: rv };
-}
-function resTarget(val, name) {
-  const rt = { val };
-  if (name) {
-    rt.name = name;
+  if (parts.length === 2) {
+    const schema = parts[0];
+    const table = parts[1];
+    validateIdentifier(schema, "schema");
+    validateIdentifier(table, "table");
+    return { schema, table };
   }
-  return { ResTarget: rt };
-}
-function columnTarget(column, alias, table, naming = identityNaming) {
-  return resTarget(columnRef(column, table, void 0, naming), alias);
-}
-function starTarget(table, naming = identityNaming) {
-  return resTarget(columnRefStar(table, naming));
-}
-function binaryExpr(operator, left, right, kind = "AEXPR_OP") {
-  const expr = {
-    kind,
-    name: [stringNode(operator)],
-    lexpr: left,
-    rexpr: right
-  };
-  return { A_Expr: expr };
-}
-function eqExpr(left, right) {
-  return binaryExpr("=", left, right);
-}
-function fkCorrelation(col1, alias1, col2, alias2, naming) {
-  return eqExpr(
-    columnRef(col1, alias1, void 0, naming),
-    columnRef(col2, alias2, void 0, naming)
+  throw new InvalidIdentifierError(
+    schemaTable,
+    "table",
+    "too many dots in qualified name (expected schema.table or table)"
   );
 }
-function neExpr(left, right) {
-  return binaryExpr("<>", left, right);
-}
-function ltExpr(left, right) {
-  return binaryExpr("<", left, right);
-}
-function lteExpr(left, right) {
-  return binaryExpr("<=", left, right);
-}
-function gtExpr(left, right) {
-  return binaryExpr(">", left, right);
-}
-function gteExpr(left, right) {
-  return binaryExpr(">=", left, right);
-}
-function likeExpr(left, right) {
-  return binaryExpr("~~", left, right, "AEXPR_LIKE");
-}
-function ilikeExpr(left, right) {
-  return binaryExpr("~~*", left, right, "AEXPR_ILIKE");
-}
-function boolExpr(type, args) {
-  const expr = {
-    boolop: type,
-    args
-  };
-  return { BoolExpr: expr };
-}
-function andExpr(...args) {
-  return boolExpr("AND_EXPR", args);
-}
-function orExpr(...args) {
-  return boolExpr("OR_EXPR", args);
+function validateIdentifiers(identifiers) {
+  for (const [value, type] of Object.entries(identifiers)) {
+    if (value) {
+      validateIdentifier(value, type);
+    }
+  }
 }
-function notExpr(arg) {
-  return boolExpr("NOT_EXPR", [arg]);
+function sanitizeForDisplay(value) {
+  return value.replace(/[\x00-\x1f\x7f]/g, "?").slice(0, 100);
 }
-function typeCast(arg, typeName, isArray = false) {
-  const tn = {
-    names: [stringNode(typeName)],
-    typemod: -1
-  };
-  if (isArray) {
-    tn.arrayBounds = [integerNode(-1)];
+function validateExtensionName(name, context = "extension") {
+  if (!name || name.length === 0) {
+    throw new InvalidIdentifierError(name, context, "cannot be empty");
   }
-  const tc = {
-    arg,
-    typeName: tn
-  };
-  return { TypeCast: tc };
-}
-function funcCall(name, args = [], options = {}) {
-  const names = Array.isArray(name) ? name.map(stringNode) : [stringNode(name)];
-  const fc = {
-    funcname: names
-  };
-  if (options.star) {
-    fc.agg_star = true;
-  } else if (args.length > 0) {
-    fc.args = args;
+  if (name.length > 63) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      `exceeds maximum length of 63 characters (got ${name.length})`
+    );
   }
-  if (options.distinct) {
-    fc.agg_distinct = true;
+  if (/[\x00-\x1f\x7f]/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains control characters"
+    );
   }
-  if (options.orderBy && options.orderBy.length > 0) {
-    fc.agg_order = options.orderBy;
+  if (/[\\]/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains backslash (forbidden in extension names)"
+    );
   }
-  if (options.filter) {
-    fc.agg_filter = options.filter;
+  if (/"/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains double-quote (identifier injection risk)"
+    );
   }
-  return { FuncCall: fc };
-}
-function coalesceExpr(args) {
-  return { CoalesceExpr: { args } };
-}
-function coalesce(...args) {
-  return funcCall("coalesce", args);
-}
-function sortBy(expr, direction = "DEFAULT", nulls = "DEFAULT") {
-  const sb = {
-    node: expr,
-    sortby_dir: direction === "ASC" ? "SORTBY_ASC" : direction === "DESC" ? "SORTBY_DESC" : "SORTBY_DEFAULT",
-    sortby_nulls: nulls === "FIRST" ? "SORTBY_NULLS_FIRST" : nulls === "LAST" ? "SORTBY_NULLS_LAST" : "SORTBY_NULLS_DEFAULT"
-  };
-  return { SortBy: sb };
-}
-function joinExpr(joinType, left, right, quals, alias) {
-  const je = {
-    jointype: joinType,
-    larg: left,
-    rarg: right
-  };
-  if (quals) {
-    je.quals = quals;
+  if (/'/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains single-quote (string injection risk)"
+    );
   }
-  if (alias) {
-    je.alias = { aliasname: alias };
+  if (/;/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains semicolon (statement injection risk)"
+    );
   }
-  return { JoinExpr: je };
-}
-function innerJoin(left, right, on, alias) {
-  return joinExpr("JOIN_INNER", left, right, on, alias);
-}
-function leftJoin(left, right, on, alias) {
-  return joinExpr("JOIN_LEFT", left, right, on, alias);
-}
-function selectStmt(options) {
-  const stmt = {
-    targetList: options.targetList
-  };
-  if (options.from && options.from.length > 0) {
-    stmt.fromClause = options.from;
+  if (/--/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains line-comment marker (--)"
+    );
   }
-  if (options.where) {
-    stmt.whereClause = options.where;
+  if (/\/\*/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains block-comment opener (/*)"
+    );
   }
-  if (options.groupBy && options.groupBy.length > 0) {
-    stmt.groupClause = options.groupBy;
+  if (/\*\//.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains block-comment closer (*/)"
+    );
   }
-  if (options.having) {
-    stmt.havingClause = options.having;
+  if (/\$\$/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains dollar-quoting ($$)"
+    );
   }
-  if (options.orderBy && options.orderBy.length > 0) {
-    stmt.sortClause = options.orderBy;
+  if (/\s/.test(name)) {
+    throw new InvalidIdentifierError(name, context, "contains whitespace");
   }
-  if (options.limit) {
-    stmt.limitCount = options.limit;
+  if (!/^[a-zA-Z0-9_\-.]+$/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains characters not allowed in extension names (only letters, digits, underscore, hyphen, and dot allowed)"
+    );
   }
-  if (options.offset) {
-    stmt.limitOffset = options.offset;
+}
+function validateCollationName(name, context = "collation") {
+  if (!name || name.length === 0) {
+    throw new InvalidIdentifierError(name, context, "cannot be empty");
   }
-  if (options.distinct === true) {
-    stmt.distinctClause = [];
-  } else if (Array.isArray(options.distinct) && options.distinct.length > 0) {
-    stmt.distinctClause = options.distinct;
+  if (Buffer.byteLength(name, "utf8") > 63) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      `exceeds maximum length of 63 bytes (got ${Buffer.byteLength(name, "utf8")})`
+    );
   }
-  if (options.withClause && options.withClause.ctes.length > 0) {
-    stmt.withClause = {
-      ctes: options.withClause.ctes,
-      recursive: options.withClause.recursive ?? false
-    };
+  if (/\x00/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains NUL byte (\\x00) which would be silently truncated by PostgreSQL"
+    );
   }
-  if (options.lockingClause) {
-    const clause = {
-      strength: options.lockingClause.strength,
-      waitPolicy: options.lockingClause.waitPolicy ?? "LockWaitBlock"
-    };
-    if (options.lockingClause.lockedRels && options.lockingClause.lockedRels.length > 0) {
-      clause.lockedRels = options.lockingClause.lockedRels;
-    }
-    stmt.lockingClause = [{ LockingClause: clause }];
+  if (/[\x01-\x1f\x7f]/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains control characters (only printable characters allowed)"
+    );
   }
-  return { SelectStmt: stmt };
-}
-function mapLockToAst(lock) {
-  return {
-    strength: STRENGTH_MAP[lock.strength],
-    waitPolicy: POLICY_MAP[lock.waitPolicy]
-  };
-}
-function insertStmt(options) {
-  const naming = options.naming ?? identityNaming;
-  const relation = {
-    relname: naming.toDatabase(options.table),
-    inh: true,
-    relpersistence: "p"
-  };
-  if (options.schema) {
-    relation.schemaname = naming.toDatabase(options.schema);
+  if (/[\\]/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains backslash (forbidden in collation names)"
+    );
   }
-  const stmt = {
-    relation
-  };
-  if (options.columns && options.columns.length > 0) {
-    stmt.cols = options.columns.map((col) => ({
-      ResTarget: { name: naming.toDatabase(col) }
-    }));
+  if (/"/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains double-quote (identifier injection risk)"
+    );
   }
-  if (options.selectQuery) {
-    stmt.selectStmt = options.selectQuery;
-  } else if (options.values && options.values.length > 0) {
-    stmt.selectStmt = {
-      SelectStmt: {
-        valuesLists: options.values.map((row) => ({ List: { items: row } }))
-      }
-    };
+  if (/'/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains single-quote (string injection risk)"
+    );
   }
-  applyReturningList(stmt, options.returning);
-  return { InsertStmt: stmt };
-}
-function updateStmt(options) {
-  const naming = options.naming ?? identityNaming;
-  const relation = {
-    relname: naming.toDatabase(options.table),
-    inh: true,
-    relpersistence: "p"
-  };
-  if (options.schema) {
-    relation.schemaname = naming.toDatabase(options.schema);
+  if (/;/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains semicolon (statement injection risk)"
+    );
   }
-  const stmt = {
-    relation,
-    targetList: options.set.map(({ column, value }) => ({
-      ResTarget: {
-        name: naming.toDatabase(column),
-        val: value
-      }
-    }))
-  };
-  if (options.where) {
-    stmt.whereClause = options.where;
+  if (/--/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains line-comment marker (--)"
+    );
   }
-  if (options.from && options.from.length > 0) {
-    stmt.fromClause = options.from;
+  if (/\/\*/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains block-comment opener (/*)"
+    );
   }
-  applyReturningList(stmt, options.returning);
-  return { UpdateStmt: stmt };
-}
-function deleteStmt(options) {
-  const naming = options.naming ?? identityNaming;
-  const relation = {
-    relname: naming.toDatabase(options.table),
-    inh: true,
-    relpersistence: "p"
-  };
-  if (options.schema) {
-    relation.schemaname = naming.toDatabase(options.schema);
+  if (/\*\//.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains block-comment closer (*/)"
+    );
   }
-  const stmt = {
-    relation
-  };
-  if (options.where) {
-    stmt.whereClause = options.where;
+  if (/\$\$/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains dollar-quoting ($$)"
+    );
   }
-  if (options.using && options.using.length > 0) {
-    stmt.usingClause = options.using;
+  if (/\s/.test(name)) {
+    throw new InvalidIdentifierError(name, context, "contains whitespace");
+  }
+  if (!/^[a-zA-Z_][a-zA-Z0-9_.-]*(?:@[A-Za-z0-9-]{1,10})?$/.test(name)) {
+    throw new InvalidIdentifierError(
+      name,
+      context,
+      "contains characters not allowed in collation names (only letters, digits, underscore, hyphen, and dot allowed; optional @modifier must be 1-10 alphanumeric/hyphen characters, e.g. @euro, @latin9, @iso8859-15)"
+    );
   }
-  applyReturningList(stmt, options.returning);
-  return { DeleteStmt: stmt };
 }
-function jsonAggSubquery(targetTable, whereExpr, alias, schemaName, naming = identityNaming, options) {
-  const targetAlias = options?.innerAlias ?? "__t__";
-  const cols = options?.columns;
-  const hasProjection = cols && cols.length > 0 && !(cols.length === 1 && cols[0] === "*");
-  let toJsonbCall;
-  if (hasProjection) {
-    const projArgs = [];
-    for (const col of cols) {
-      projArgs.push({ A_Const: { sval: { sval: naming.toDatabase(col) } } });
-      projArgs.push(columnRef(col, targetAlias, void 0, naming));
-    }
-    toJsonbCall = {
-      FuncCall: {
-        funcname: [stringNode("jsonb_build_object")],
-        args: projArgs
-      }
-    };
-  } else {
-    const rowRef = {
-      ColumnRef: {
-        fields: [stringNode(targetAlias)]
-      }
-    };
-    toJsonbCall = {
-      FuncCall: {
-        funcname: [stringNode("to_jsonb")],
-        args: [rowRef]
-      }
-    };
+function validateSqlExpression(sql, context) {
+  if (/[;]|--|\/\*|\*\/|\$\$|\\/.test(sql)) {
+    throw new Error(
+      `Unsafe SQL expression in ${context}: contains forbidden characters (;, --, /*, */, "$$" (dollar-quoted strings), \\). Value: "${sql}"`
+    );
   }
-  if (options?.childNodes && options.childNodes.length > 0) {
-    const buildObjectArgs = [];
-    for (const child of options.childNodes) {
-      buildObjectArgs.push({ A_Const: { sval: { sval: child.key } } });
-      buildObjectArgs.push(child.node);
-    }
-    const jsonbBuildObject = {
-      FuncCall: {
-        funcname: [stringNode("jsonb_build_object")],
-        args: buildObjectArgs
-      }
-    };
-    toJsonbCall = {
-      A_Expr: {
-        kind: "AEXPR_OP",
-        name: [stringNode("||")],
-        lexpr: toJsonbCall,
-        rexpr: jsonbBuildObject
+}
+function validateDbTypeName(type) {
+  if (!SAFE_TYPE_PATTERN.test(type)) {
+    throw new Error(
+      `Unsafe database type name: "${type}". Must match PostgreSQL type name rules.`
+    );
+  }
+  return type;
+}
+var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_TYPE_PATTERN;
+var init_validate = __esm({
+  "src/validate.ts"() {
+    "use strict";
+    SQL_RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
+      "all",
+      "analyse",
+      "analyze",
+      "and",
+      "any",
+      "array",
+      "as",
+      "asc",
+      "asymmetric",
+      "authorization",
+      "binary",
+      "both",
+      "case",
+      "cast",
+      "check",
+      "collate",
+      "collation",
+      "column",
+      "concurrently",
+      "constraint",
+      "create",
+      "cross",
+      "current_catalog",
+      "current_date",
+      "current_role",
+      "current_schema",
+      "current_time",
+      "current_timestamp",
+      "current_user",
+      "default",
+      "deferrable",
+      "desc",
+      "distinct",
+      "do",
+      "else",
+      "end",
+      "except",
+      "false",
+      "fetch",
+      "for",
+      "foreign",
+      "freeze",
+      "from",
+      "full",
+      "grant",
+      "group",
+      "having",
+      "ilike",
+      "in",
+      "initially",
+      "inner",
+      "intersect",
+      "into",
+      "is",
+      "isnull",
+      "join",
+      "lateral",
+      "leading",
+      "left",
+      "like",
+      "limit",
+      "localtime",
+      "localtimestamp",
+      "natural",
+      "not",
+      "notnull",
+      "null",
+      "offset",
+      "on",
+      "only",
+      "or",
+      "order",
+      "outer",
+      "overlaps",
+      "placing",
+      "primary",
+      "references",
+      "returning",
+      "right",
+      "select",
+      "session_user",
+      "similar",
+      "some",
+      "symmetric",
+      "table",
+      "timestamp",
+      "tablesample",
+      "then",
+      "to",
+      "trailing",
+      "true",
+      "union",
+      "unique",
+      "user",
+      "using",
+      "variadic",
+      "verbose",
+      "when",
+      "where",
+      "window",
+      "with"
+    ]);
+    InvalidIdentifierError = class extends Error {
+      constructor(identifier, identifierType, reason) {
+        super(`Invalid ${identifierType} identifier "${identifier}": ${reason}`);
+        this.identifier = identifier;
+        this.identifierType = identifierType;
+        this.reason = reason;
+        this.name = "InvalidIdentifierError";
       }
+      identifier;
+      identifierType;
+      reason;
     };
+    SAFE_TYPE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])?$/;
   }
-  const jsonAggCall = {
-    FuncCall: {
-      funcname: [stringNode("json_agg")],
-      args: [toJsonbCall]
-    }
-  };
-  const fromTable = rangeVar(targetTable, targetAlias, schemaName, naming);
-  const limitNode = options?.limit !== void 0 ? { A_Const: { ival: { ival: options.limit } } } : void 0;
-  const innerSelect = selectStmt({
-    targetList: [{ ResTarget: { val: jsonAggCall } }],
-    from: [fromTable],
-    where: whereExpr,
-    ...limitNode && { limit: limitNode }
-  });
-  const subLink = {
-    SubLink: {
-      subLinkType: "EXPR_SUBLINK",
-      // scalar subquery
-      subselect: innerSelect
-    }
-  };
-  const emptyArrayDefault = {
-    TypeCast: {
-      arg: { A_Const: { sval: { sval: "[]" } } },
-      typeName: {
-        names: [stringNode("json")],
-        typemod: -1
-      }
+});
+
+// src/ast-helpers.ts
+import { normalizeSQL } from "@dbsp/core";
+function applyReturningList(stmt, returning) {
+  if (returning && returning.length > 0) {
+    stmt.returningList = returning;
+  }
+}
+function stringNode(value) {
+  return { String: { sval: value } };
+}
+function integerNode(value) {
+  return { Integer: { ival: value } };
+}
+function floatNode(value) {
+  return { Float: { fval: value } };
+}
+function booleanConstNode(value) {
+  return {
+    A_Const: {
+      boolval: { boolval: value }
     }
   };
-  const coalesceNode = coalesceExpr([subLink, emptyArrayDefault]);
+}
+function nullConstNode() {
   return {
-    ResTarget: {
-      val: coalesceNode,
-      name: alias
+    A_Const: {
+      isnull: true
     }
   };
 }
-function jsonAggCorrelation(parentAlias, parentColumn, targetAlias, targetColumn, naming = identityNaming) {
-  return eqExpr(
-    columnRef(targetColumn, targetAlias, void 0, naming),
-    columnRef(parentColumn, parentAlias, void 0, naming)
-  );
-}
-var STRENGTH_MAP, POLICY_MAP;
-var init_ast_helpers = __esm({
-  "src/ast-helpers.ts"() {
-    "use strict";
-    init_naming_plugin();
-    STRENGTH_MAP = {
-      forUpdate: "LCS_FORUPDATE",
-      forNoKeyUpdate: "LCS_FORNOKEYUPDATE",
-      forShare: "LCS_FORSHARE",
-      forKeyShare: "LCS_FORKEYSHARE"
-    };
-    POLICY_MAP = {
-      block: "LockWaitBlock",
-      skipLocked: "LockWaitSkip",
-      noWait: "LockWaitError"
-    };
+function columnRef(column, table, schema, naming = identityNaming) {
+  const fields = [];
+  if (schema) {
+    const dbSchema = naming.toDatabase(schema);
+    validateIdentifier(dbSchema, "schema");
+    fields.push(stringNode(dbSchema));
   }
-});
-
-// src/param-ref.ts
-function validateParamRef(paramRef) {
-  const errors = [];
-  if (paramRef.number === void 0) {
-    errors.push("ParamRef.number is required");
-  } else if (!Number.isInteger(paramRef.number)) {
-    errors.push(`ParamRef.number must be an integer, got: ${paramRef.number}`);
-  } else if (paramRef.number < 1) {
-    errors.push(
-      `ParamRef.number must be >= 1 (1-based indexing), got: ${paramRef.number}`
-    );
-  } else if (paramRef.number > 65535) {
-    errors.push(
-      `ParamRef.number exceeds maximum (65535), got: ${paramRef.number}`
-    );
+  if (table) {
+    const dbTable = naming.toDatabase(table);
+    validateIdentifier(dbTable, "table");
+    fields.push(stringNode(dbTable));
   }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
+  const dbColumn = naming.toDatabase(column);
+  if (dbColumn !== "*" && !/^\d+$/.test(dbColumn)) {
+    validateIdentifier(dbColumn, "column");
+  }
+  fields.push(stringNode(dbColumn));
+  return { ColumnRef: { fields } };
 }
-function createParamRef(number, location) {
-  const paramRef = location !== void 0 ? { number, location } : { number };
-  const result = validateParamRef(paramRef);
-  if (!result.valid) {
-    throw new Error(`Invalid ParamRef: ${result.errors.join(", ")}`);
+function columnRefStar(table, naming = identityNaming) {
+  const fields = [];
+  if (table) {
+    fields.push(stringNode(naming.toDatabase(table)));
   }
-  return { ParamRef: paramRef };
+  fields.push({ A_Star: {} });
+  return { ColumnRef: { fields } };
 }
-function createTypeCastParamRef(paramNumber, typeName, isArray = false, location) {
-  const paramRefNode = createParamRef(paramNumber, location);
-  const typeNameNode = isArray ? {
-    names: [{ String: { sval: typeName } }],
-    typemod: -1,
-    arrayBounds: [{ Integer: { ival: -1 } }]
-  } : {
-    names: [{ String: { sval: typeName } }],
-    typemod: -1
-  };
-  const typeCast2 = location !== void 0 ? {
-    arg: paramRefNode,
-    typeName: typeNameNode,
-    location
-  } : {
-    arg: paramRefNode,
-    typeName: typeNameNode
+function rangeVar(table, alias, schema, naming = identityNaming) {
+  const dbTable = naming.toDatabase(table);
+  validateIdentifier(dbTable, "table");
+  const rv = {
+    relname: dbTable,
+    inh: true,
+    relpersistence: "p"
   };
-  return { TypeCast: typeCast2 };
+  if (schema) {
+    const dbSchema = naming.toDatabase(schema);
+    validateIdentifier(dbSchema, "schema");
+    rv.schemaname = dbSchema;
+  }
+  if (alias) {
+    const dbAlias = naming.toDatabase(alias);
+    validateIdentifier(dbAlias, "alias");
+    rv.alias = { aliasname: dbAlias };
+  }
+  return { RangeVar: rv };
 }
-function createEqualityExpr(columnName, paramNumber, tableName, location) {
-  const fields = tableName ? [{ String: { sval: tableName } }, { String: { sval: columnName } }] : [{ String: { sval: columnName } }];
-  const kind = "AEXPR_OP";
-  const expr = location !== void 0 ? {
-    kind,
-    name: [{ String: { sval: "=" } }],
-    lexpr: { ColumnRef: { fields, location } },
-    rexpr: createParamRef(paramNumber, location),
-    location
-  } : {
+function resTarget(val, name) {
+  const rt = { val };
+  if (name) {
+    rt.name = name;
+  }
+  return { ResTarget: rt };
+}
+function columnTarget(column, alias, table, naming = identityNaming) {
+  return resTarget(columnRef(column, table, void 0, naming), alias);
+}
+function starTarget(table, naming = identityNaming) {
+  return resTarget(columnRefStar(table, naming));
+}
+function binaryExpr(operator, left, right, kind = "AEXPR_OP") {
+  const expr = {
     kind,
-    name: [{ String: { sval: "=" } }],
-    lexpr: { ColumnRef: { fields } },
-    rexpr: createParamRef(paramNumber)
+    name: [stringNode(operator)],
+    lexpr: left,
+    rexpr: right
   };
   return { A_Expr: expr };
 }
-function createAnyExpr(columnName, paramNumber, tableName, location) {
-  const fields = tableName ? [{ String: { sval: tableName } }, { String: { sval: columnName } }] : [{ String: { sval: columnName } }];
-  const kind = "AEXPR_OP";
-  const anyCall = location !== void 0 ? {
-    funcname: [{ String: { sval: "any" } }],
-    args: [createParamRef(paramNumber, location)],
-    location
-  } : {
-    funcname: [{ String: { sval: "any" } }],
-    args: [createParamRef(paramNumber)]
-  };
-  const expr = location !== void 0 ? {
-    kind,
-    name: [{ String: { sval: "=" } }],
-    lexpr: { ColumnRef: { fields, location } },
-    rexpr: { FuncCall: anyCall },
-    location
-  } : {
-    kind,
-    name: [{ String: { sval: "=" } }],
-    lexpr: { ColumnRef: { fields } },
-    rexpr: { FuncCall: anyCall }
+function eqExpr(left, right) {
+  return binaryExpr("=", left, right);
+}
+function fkCorrelation(col1, alias1, col2, alias2, naming) {
+  return eqExpr(
+    columnRef(col1, alias1, void 0, naming),
+    columnRef(col2, alias2, void 0, naming)
+  );
+}
+function neExpr(left, right) {
+  return binaryExpr("<>", left, right);
+}
+function ltExpr(left, right) {
+  return binaryExpr("<", left, right);
+}
+function lteExpr(left, right) {
+  return binaryExpr("<=", left, right);
+}
+function gtExpr(left, right) {
+  return binaryExpr(">", left, right);
+}
+function gteExpr(left, right) {
+  return binaryExpr(">=", left, right);
+}
+function likeExpr(left, right) {
+  return binaryExpr("~~", left, right, "AEXPR_LIKE");
+}
+function ilikeExpr(left, right) {
+  return binaryExpr("~~*", left, right, "AEXPR_ILIKE");
+}
+function boolExpr(type, args) {
+  const expr = {
+    boolop: type,
+    args
   };
-  return { A_Expr: expr };
+  return { BoolExpr: expr };
 }
-function collectAndValidateParamRefs(node) {
-  const paramRefs = [];
-  function traverse(n, path) {
-    if (n === null || n === void 0) return;
-    if (typeof n === "object") {
-      const obj = n;
-      if ("ParamRef" in obj && obj.ParamRef !== void 0) {
-        paramRefs.push({
-          paramRef: obj.ParamRef,
-          path
-        });
-      }
-      for (const [key, value] of Object.entries(obj)) {
-        if (Array.isArray(value)) {
-          value.forEach((item, index) => {
-            traverse(item, `${path}.${key}[${index}]`);
-          });
-        } else if (typeof value === "object") {
-          traverse(value, `${path}.${key}`);
-        }
-      }
-    }
+function andExpr(...args) {
+  return boolExpr("AND_EXPR", args);
+}
+function orExpr(...args) {
+  return boolExpr("OR_EXPR", args);
+}
+function notExpr(arg) {
+  return boolExpr("NOT_EXPR", [arg]);
+}
+function typeCast(arg, typeName, isArray = false) {
+  const tn = {
+    names: [stringNode(typeName)],
+    typemod: -1
+  };
+  if (isArray) {
+    tn.arrayBounds = [integerNode(-1)];
   }
-  traverse(node, "root");
-  const validationResults = paramRefs.map((p) => validateParamRef(p.paramRef));
-  const allValid = validationResults.every((r) => r.valid);
-  return { paramRefs, validationResults, allValid };
+  const tc = {
+    arg,
+    typeName: tn
+  };
+  return { TypeCast: tc };
 }
-var init_param_ref = __esm({
-  "src/param-ref.ts"() {
-    "use strict";
+function funcCall(name, args = [], options = {}) {
+  const names = Array.isArray(name) ? name.map(stringNode) : [stringNode(name)];
+  const fc = {
+    funcname: names
+  };
+  if (options.star) {
+    fc.agg_star = true;
+  } else if (args.length > 0) {
+    fc.args = args;
   }
-});
-
-// src/handlers/expression/case-value.ts
-function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler) {
-  if (value === null || value === void 0) {
-    return nullConstNode();
+  if (options.distinct) {
+    fc.agg_distinct = true;
   }
-  if (typeof value === "string") {
-    return columnRef(value, alias, schema, naming);
+  if (options.orderBy && options.orderBy.length > 0) {
+    fc.agg_order = options.orderBy;
   }
-  if (typeof value !== "object") {
-    const idx = ++state.paramIndex;
-    state.parameters.push(value);
-    return createParamRef(idx);
+  if (options.filter) {
+    fc.agg_filter = options.filter;
   }
-  const expr = value;
-  switch (expr.kind) {
-    case "literal":
-      if (expr.value === null || expr.value === void 0)
-        return nullConstNode();
-      if (typeof expr.value === "boolean")
-        return booleanConstNode(expr.value);
-      if (typeof expr.value === "number") {
-        if (Number.isInteger(expr.value))
-          return integerNode(expr.value);
-        return floatNode(String(expr.value));
-      }
-      {
-        const idx = ++state.paramIndex;
-        state.parameters.push(expr.value);
-        return createParamRef(idx);
-      }
-    case "column":
-      return columnRef(expr.column, alias, schema, naming);
-    case "arithmetic": {
-      const left = resolveCaseValue(
-        expr.left,
-        alias,
-        schema,
-        naming,
-        state,
-        nestedCaseHandler
-      );
-      const right = resolveCaseValue(
-        expr.right,
-        alias,
-        schema,
-        naming,
-        state,
-        nestedCaseHandler
-      );
-      return {
-        A_Expr: {
-          kind: "AEXPR_OP",
-          name: [{ String: { sval: expr.operator } }],
-          lexpr: left,
-          rexpr: right
-        }
-      };
+  return { FuncCall: fc };
+}
+function coalesceExpr(args) {
+  return { CoalesceExpr: { args } };
+}
+function coalesce(...args) {
+  return funcCall("coalesce", args);
+}
+function sortBy(expr, direction = "DEFAULT", nulls = "DEFAULT") {
+  const sb = {
+    node: expr,
+    sortby_dir: direction === "ASC" ? "SORTBY_ASC" : direction === "DESC" ? "SORTBY_DESC" : "SORTBY_DEFAULT",
+    sortby_nulls: nulls === "FIRST" ? "SORTBY_NULLS_FIRST" : nulls === "LAST" ? "SORTBY_NULLS_LAST" : "SORTBY_NULLS_DEFAULT"
+  };
+  return { SortBy: sb };
+}
+function joinExpr(joinType, left, right, quals, alias) {
+  const je = {
+    jointype: joinType,
+    larg: left,
+    rarg: right
+  };
+  if (quals) {
+    je.quals = quals;
+  }
+  if (alias) {
+    je.alias = { aliasname: alias };
+  }
+  return { JoinExpr: je };
+}
+function innerJoin(left, right, on, alias) {
+  return joinExpr("JOIN_INNER", left, right, on, alias);
+}
+function leftJoin(left, right, on, alias) {
+  return joinExpr("JOIN_LEFT", left, right, on, alias);
+}
+function selectStmt(options) {
+  const stmt = {
+    targetList: options.targetList
+  };
+  if (options.from && options.from.length > 0) {
+    stmt.fromClause = options.from;
+  }
+  if (options.where) {
+    stmt.whereClause = options.where;
+  }
+  if (options.groupBy && options.groupBy.length > 0) {
+    stmt.groupClause = options.groupBy;
+  }
+  if (options.having) {
+    stmt.havingClause = options.having;
+  }
+  if (options.orderBy && options.orderBy.length > 0) {
+    stmt.sortClause = options.orderBy;
+  }
+  if (options.limit) {
+    stmt.limitCount = options.limit;
+  }
+  if (options.offset) {
+    stmt.limitOffset = options.offset;
+  }
+  if (options.distinct === true) {
+    stmt.distinctClause = [];
+  } else if (Array.isArray(options.distinct) && options.distinct.length > 0) {
+    stmt.distinctClause = options.distinct;
+  }
+  if (options.withClause && options.withClause.ctes.length > 0) {
+    stmt.withClause = {
+      ctes: options.withClause.ctes,
+      recursive: options.withClause.recursive ?? false
+    };
+  }
+  if (options.lockingClause) {
+    const clause = {
+      strength: options.lockingClause.strength,
+      waitPolicy: options.lockingClause.waitPolicy ?? "LockWaitBlock"
+    };
+    if (options.lockingClause.lockedRels && options.lockingClause.lockedRels.length > 0) {
+      clause.lockedRels = options.lockingClause.lockedRels;
     }
-    // biome-ignore lint/suspicious/noFallthroughSwitchClause: intentional — no nested handler → parameterize via default
-    case "case":
-      if (nestedCaseHandler) {
-        return nestedCaseHandler(expr);
+    stmt.lockingClause = [{ LockingClause: clause }];
+  }
+  return { SelectStmt: stmt };
+}
+function mapLockToAst(lock) {
+  return {
+    strength: STRENGTH_MAP[lock.strength],
+    waitPolicy: POLICY_MAP[lock.waitPolicy]
+  };
+}
+function insertStmt(options) {
+  const naming = options.naming ?? identityNaming;
+  const relation = {
+    relname: naming.toDatabase(options.table),
+    inh: true,
+    relpersistence: "p"
+  };
+  if (options.schema) {
+    relation.schemaname = naming.toDatabase(options.schema);
+  }
+  const stmt = {
+    relation
+  };
+  if (options.columns && options.columns.length > 0) {
+    stmt.cols = options.columns.map((col) => ({
+      ResTarget: { name: naming.toDatabase(col) }
+    }));
+  }
+  if (options.selectQuery) {
+    stmt.selectStmt = options.selectQuery;
+  } else if (options.values && options.values.length > 0) {
+    stmt.selectStmt = {
+      SelectStmt: {
+        valuesLists: options.values.map((row) => ({ List: { items: row } }))
       }
-    // falls through
-    default: {
-      const idx = ++state.paramIndex;
-      state.parameters.push(value);
-      return createParamRef(idx);
-    }
+    };
   }
+  applyReturningList(stmt, options.returning);
+  return { InsertStmt: stmt };
 }
-var init_case_value = __esm({
-  "src/handlers/expression/case-value.ts"() {
-    "use strict";
-    init_ast_helpers();
-    init_param_ref();
+function updateStmt(options) {
+  const naming = options.naming ?? identityNaming;
+  const relation = {
+    relname: naming.toDatabase(options.table),
+    inh: true,
+    relpersistence: "p"
+  };
+  if (options.schema) {
+    relation.schemaname = naming.toDatabase(options.schema);
   }
-});
-
-// src/handlers/expression/custom.ts
-function registerWhereDispatcherFactory(factory) {
-  _whereDispatcherFactory = factory;
+  const stmt = {
+    relation,
+    targetList: options.set.map(({ column, value }) => ({
+      ResTarget: {
+        name: naming.toDatabase(column),
+        val: value
+      }
+    }))
+  };
+  if (options.where) {
+    stmt.whereClause = options.where;
+  }
+  if (options.from && options.from.length > 0) {
+    stmt.fromClause = options.from;
+  }
+  applyReturningList(stmt, options.returning);
+  return { UpdateStmt: stmt };
 }
-function _createWhereDispatcher() {
-  if (!_whereDispatcherFactory) {
-    throw new Error(
-      "compileExpressionIntent (case): WHERE dispatcher not initialized. Ensure compile-where.ts is imported before any CASE expression is compiled."
-    );
+function deleteStmt(options) {
+  const naming = options.naming ?? identityNaming;
+  const relation = {
+    relname: naming.toDatabase(options.table),
+    inh: true,
+    relpersistence: "p"
+  };
+  if (options.schema) {
+    relation.schemaname = naming.toDatabase(options.schema);
   }
-  return _whereDispatcherFactory();
+  const stmt = {
+    relation
+  };
+  if (options.where) {
+    stmt.whereClause = options.where;
+  }
+  if (options.using && options.using.length > 0) {
+    stmt.usingClause = options.using;
+  }
+  applyReturningList(stmt, options.returning);
+  return { DeleteStmt: stmt };
 }
-function compileExpressionIntent(intent, ctx, state) {
-  const kind = intent.kind;
-  switch (kind) {
-    case "customOp": {
-      const i = intent;
-      const leftNode = compileExpressionIntent(i.left, ctx, state);
-      const rightNode = compileExpressionIntent(i.right, ctx, state);
-      return {
-        A_Expr: {
-          kind: "AEXPR_OP",
-          name: [{ String: { sval: i.operator } }],
-          lexpr: leftNode,
-          rexpr: rightNode
-        }
-      };
-    }
-    case "customFn": {
-      const i = intent;
-      const nameParts = i.name.split(".");
-      const argNodes = i.args.map(
-        (arg) => compileExpressionIntent(arg, ctx, state)
-      );
-      const orderByNodes = i.aggOrderBy && i.aggOrderBy.length > 0 ? i.aggOrderBy.map((ob) => {
-        const colNode = columnRef(
-          ob.field,
-          void 0,
-          void 0,
-          ctx.naming
-        );
-        return sortBy(colNode, ob.direction === "desc" ? "DESC" : "ASC");
-      }) : void 0;
-      return funcCall(nameParts, argNodes, {
-        ...orderByNodes ? { orderBy: orderByNodes } : {}
-      });
-    }
-    case "ref": {
-      const i = intent;
-      const dotIdx = i.column.indexOf(".");
-      if (dotIdx !== -1) {
-        const table = i.column.slice(0, dotIdx);
-        const col = i.column.slice(dotIdx + 1);
-        return columnRef(col, table, void 0, ctx.naming);
-      }
-      return columnRef(i.column, void 0, void 0, ctx.naming);
+function jsonAggSubquery(targetTable, whereExpr, alias, schemaName, naming = identityNaming, options) {
+  const targetAlias = options?.innerAlias ?? "__t__";
+  const cols = options?.columns;
+  const hasProjection = cols && cols.length > 0 && !(cols.length === 1 && cols[0] === "*");
+  let toJsonbCall;
+  if (hasProjection) {
+    const projArgs = [];
+    for (const col of cols) {
+      projArgs.push({ A_Const: { sval: { sval: naming.toDatabase(col) } } });
+      projArgs.push(columnRef(col, targetAlias, void 0, naming));
     }
-    case "param": {
-      const i = intent;
-      const idx = ++state.paramIndex;
-      state.parameters.push(i.value);
-      return createParamRef(idx);
-    }
-    case "cast": {
-      const i = intent;
-      const argNode = compileExpressionIntent(i.expr, ctx, state);
-      return typeCast(argNode, i.typeName);
-    }
-    case "literal": {
-      const i = intent;
-      if (i.value === null || i.value === void 0) {
-        return nullConstNode();
-      }
-      if (typeof i.value === "boolean") {
-        return booleanConstNode(i.value);
+    toJsonbCall = {
+      FuncCall: {
+        funcname: [stringNode("jsonb_build_object")],
+        args: projArgs
       }
-      if (typeof i.value === "number") {
-        if (Number.isInteger(i.value)) {
-          return integerNode(i.value);
-        }
-        return floatNode(String(i.value));
+    };
+  } else {
+    const rowRef = {
+      ColumnRef: {
+        fields: [stringNode(targetAlias)]
       }
-      if (typeof i.value === "string") {
-        return {
-          A_Const: { sval: { sval: i.value } }
-        };
+    };
+    toJsonbCall = {
+      FuncCall: {
+        funcname: [stringNode("to_jsonb")],
+        args: [rowRef]
       }
-      return {
-        A_Const: { sval: { sval: String(i.value) } }
-      };
-    }
-    case "unary": {
-      const i = intent;
-      const operandNode = compileExpressionIntent(i.operand, ctx, state);
-      return {
-        A_Expr: {
-          kind: "AEXPR_OP",
-          name: [{ String: { sval: i.operator } }],
-          rexpr: operandNode
-        }
-      };
-    }
-    case "namedArg": {
-      const nae = intent;
-      const argNode = compileExpressionIntent(nae.value, ctx, state);
-      return {
-        NamedArgExpr: {
-          arg: argNode,
-          name: nae.name,
-          argnumber: -1
-        }
-      };
-    }
-    case "star":
-      return {
-        ColumnRef: { fields: [{ A_Star: {} }] }
-      };
-    case "array": {
-      const ae = intent;
-      const elements = ae.elements.map(
-        (el) => compileExpressionIntent(el, ctx, state)
-      );
-      return { A_ArrayExpr: { elements } };
+    };
+  }
+  if (options?.childNodes && options.childNodes.length > 0) {
+    const buildObjectArgs = [];
+    for (const child of options.childNodes) {
+      buildObjectArgs.push({ A_Const: { sval: { sval: child.key } } });
+      buildObjectArgs.push(child.node);
     }
-    case "subquery": {
-      const sq = intent;
-      if (!ctx.compileSubquery) {
-        throw new Error(
-          "compileExpressionIntent: 'subquery' expression kind requires ctx.compileSubquery to be set. Use asExpr() only in .columns() context, not in standalone expressions."
-        );
+    const jsonbBuildObject = {
+      FuncCall: {
+        funcname: [stringNode("jsonb_build_object")],
+        args: buildObjectArgs
       }
-      const { ast: innerAst, parameters: innerParams } = ctx.compileSubquery(
-        sq.query,
-        state.paramIndex
-      );
-      for (const p of innerParams) {
-        state.parameters.push(p);
+    };
+    toJsonbCall = {
+      A_Expr: {
+        kind: "AEXPR_OP",
+        name: [stringNode("||")],
+        lexpr: toJsonbCall,
+        rexpr: jsonbBuildObject
       }
-      state.paramIndex += innerParams.length;
-      return {
-        SubLink: {
-          subLinkType: "EXPR_SUBLINK",
-          subselect: innerAst
-        }
-      };
+    };
+  }
+  const jsonAggCall = {
+    FuncCall: {
+      funcname: [stringNode("json_agg")],
+      args: [toJsonbCall]
     }
-    case "relationColumn": {
-      const rc = intent;
-      const alias = state.aliases.get(rc.relation) ?? rc.relation;
-      return columnRef(rc.column, alias, void 0, ctx.naming);
+  };
+  const fromTable = rangeVar(targetTable, targetAlias, schemaName, naming);
+  const limitNode = options?.limit !== void 0 ? { A_Const: { ival: { ival: options.limit } } } : void 0;
+  const innerSelect = selectStmt({
+    targetList: [{ ResTarget: { val: jsonAggCall } }],
+    from: [fromTable],
+    where: whereExpr,
+    ...limitNode && { limit: limitNode }
+  });
+  const subLink = {
+    SubLink: {
+      subLinkType: "EXPR_SUBLINK",
+      // scalar subquery
+      subselect: innerSelect
     }
-    case "case": {
-      const dispatch = _createWhereDispatcher();
-      const caseIntent = intent;
-      if (!caseIntent.when || caseIntent.when.length === 0) {
-        throw new Error("CASE expression requires at least one WHEN clause");
-      }
-      const caseArgs = caseIntent.when.map((branch) => {
-        const whenNode = dispatch(
-          branch.condition,
-          ctx,
-          state
-        );
-        const thenNode = compileExpressionIntent(branch.result, ctx, state);
-        return {
-          CaseWhen: { expr: whenNode, result: thenNode }
-        };
-      });
-      let defresult;
-      if (caseIntent.else !== void 0) {
-        defresult = compileExpressionIntent(caseIntent.else, ctx, state);
+  };
+  const emptyArrayDefault = {
+    TypeCast: {
+      arg: { A_Const: { sval: { sval: "[]" } } },
+      typeName: {
+        names: [stringNode("json")],
+        typemod: -1
       }
-      return {
-        CaseExpr: {
-          args: caseArgs,
-          ...defresult !== void 0 ? { defresult } : {}
-        }
-      };
     }
-    default: {
-      throw new Error(
-        `compileExpressionIntent: unsupported expression kind '${kind}'`
-      );
+  };
+  const coalesceNode = coalesceExpr([subLink, emptyArrayDefault]);
+  return {
+    ResTarget: {
+      val: coalesceNode,
+      name: alias
     }
-  }
+  };
 }
-var _whereDispatcherFactory, customExpressionHandler;
-var init_custom = __esm({
-  "src/handlers/expression/custom.ts"() {
+function jsonAggCorrelation(parentAlias, parentColumn, targetAlias, targetColumn, naming = identityNaming) {
+  return eqExpr(
+    columnRef(targetColumn, targetAlias, void 0, naming),
+    columnRef(parentColumn, parentAlias, void 0, naming)
+  );
+}
+var STRENGTH_MAP, POLICY_MAP;
+var init_ast_helpers = __esm({
+  "src/ast-helpers.ts"() {
     "use strict";
-    init_ast_helpers();
-    init_param_ref();
-    customExpressionHandler = {
-      types: [
-        "customOp",
-        "customFn",
-        "ref",
-        "param",
-        "cast",
-        "unary",
-        "customExpression"
-      ],
-      compile(decision, ctx, state) {
-        const expressionIntent = decision.expressionIntent;
-        return compileExpressionIntent(expressionIntent, ctx, state);
-      }
+    init_naming_plugin();
+    init_validate();
+    STRENGTH_MAP = {
+      forUpdate: "LCS_FORUPDATE",
+      forNoKeyUpdate: "LCS_FORNOKEYUPDATE",
+      forShare: "LCS_FORSHARE",
+      forKeyShare: "LCS_FORKEYSHARE"
+    };
+    POLICY_MAP = {
+      block: "LockWaitBlock",
+      skipLocked: "LockWaitSkip",
+      noWait: "LockWaitError"
     };
   }
 });
 
-// src/select-expression-handlers.ts
-function handleColumnExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "select",
-    column: expr.column,
-    table: rootTable
+// src/param-ref.ts
+function validateParamRef(paramRef) {
+  const errors = [];
+  if (paramRef.number === void 0) {
+    errors.push("ParamRef.number is required");
+  } else if (!Number.isInteger(paramRef.number)) {
+    errors.push(`ParamRef.number must be an integer, got: ${paramRef.number}`);
+  } else if (paramRef.number < 1) {
+    errors.push(
+      `ParamRef.number must be >= 1 (1-based indexing), got: ${paramRef.number}`
+    );
+  } else if (paramRef.number > 65535) {
+    errors.push(
+      `ParamRef.number exceeds maximum (65535), got: ${paramRef.number}`
+    );
+  }
+  return {
+    valid: errors.length === 0,
+    errors
   };
-  const alias = expr.as ?? expr.alias;
-  if (alias) decision.alias = alias;
-  decisions.push(decision);
 }
-function handleAggregateExpression(expr, rootTable, decisions, applyFilter) {
-  const aggFunc = expr.function;
-  const aggField = expr.field;
-  const aggAs = expr.as;
-  const aggDistinct = expr.distinct;
-  const aggFilter = expr.filter;
-  if (aggFunc === "count" && !aggField) {
-    const decision = {
-      type: "selectFunction",
-      function: "count",
-      column: "*",
-      table: rootTable
-    };
-    if (aggAs) decision.alias = aggAs;
-    applyFilter(decision, aggFilter, rootTable);
-    decisions.push(decision);
-  } else if (aggFunc === "count" && aggDistinct && aggField) {
-    const decision = {
-      type: "selectFunction",
-      function: "countDistinct",
-      column: aggField,
-      table: rootTable
-    };
-    if (aggAs) decision.alias = aggAs;
-    applyFilter(decision, aggFilter, rootTable);
-    decisions.push(decision);
-  } else {
-    const decision = {
-      type: "selectFunction",
-      function: aggFunc,
-      table: rootTable
-    };
-    if (aggField) decision.column = aggField;
-    if (aggAs) decision.alias = aggAs;
-    applyFilter(decision, aggFilter, rootTable);
-    decisions.push(decision);
+function createParamRef(number, location) {
+  const paramRef = location !== void 0 ? { number, location } : { number };
+  const result = validateParamRef(paramRef);
+  if (!result.valid) {
+    throw new Error(`Invalid ParamRef: ${result.errors.join(", ")}`);
   }
+  return { ParamRef: paramRef };
 }
-function handleCoalesceExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectFunction",
-    function: "coalesce",
-    args: expr.fields,
-    table: rootTable
-  };
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
-}
-function handleRawExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectFunction",
-    function: "raw",
-    args: [expr.sql],
-    table: rootTable
-  };
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
-}
-function handleWindowExpression(expr, rootTable, decisions) {
-  const windowFunc = expr.function;
-  const windowAlias = expr.alias;
-  const windowField = expr.field;
-  const over = expr.over;
-  const decision = {
-    type: "selectWindow",
-    function: windowFunc,
-    alias: windowAlias,
-    table: rootTable
-  };
-  if (windowField) decision.field = windowField;
-  if (over.partitionBy) decision.partitionBy = over.partitionBy;
-  if (over.orderBy) decision.orderBy = over.orderBy;
-  const windowOffset = expr.offset;
-  const windowDefault = expr.defaultValue;
-  if (windowOffset !== void 0) decision.args = [windowOffset];
-  if (windowDefault !== void 0) decision.value = windowDefault;
-  decisions.push(decision);
-}
-function handleCaseExpression(expr, rootTable, decisions, _applyFilter, convertCondition) {
-  const whenClauses = expr.when;
-  const conditions = whenClauses.map((wc) => ({
-    when: convertCondition(wc.condition, rootTable),
-    // biome-ignore lint/suspicious/noThenProperty: intentional reserved word in decision object
-    then: wc.result
-  }));
-  const decision = {
-    type: "selectExpression",
-    expressionType: "case",
-    table: rootTable
+function createTypeCastParamRef(paramNumber, typeName, isArray = false, location) {
+  const paramRefNode = createParamRef(paramNumber, location);
+  const typeNameNode = isArray ? {
+    names: [{ String: { sval: typeName } }],
+    typemod: -1,
+    arrayBounds: [{ Integer: { ival: -1 } }]
+  } : {
+    names: [{ String: { sval: typeName } }],
+    typemod: -1
   };
-  decision.conditions = conditions;
-  if (expr.else) {
-    decision.value = expr.else;
-  }
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
-}
-function handleRelationColumnExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectRelationColumn",
-    relation: expr.relation,
-    column: expr.column ?? "*",
-    table: rootTable
+  const typeCast2 = location !== void 0 ? {
+    arg: paramRefNode,
+    typeName: typeNameNode,
+    location
+  } : {
+    arg: paramRefNode,
+    typeName: typeNameNode
   };
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
+  return { TypeCast: typeCast2 };
 }
-function handleArithmeticExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectArithmetic",
-    operator: expr.operator,
-    args: [expr.left, expr.right],
-    table: rootTable
+function createEqualityExpr(columnName, paramNumber, tableName, location) {
+  const fields = tableName ? [{ String: { sval: tableName } }, { String: { sval: columnName } }] : [{ String: { sval: columnName } }];
+  const kind = "AEXPR_OP";
+  const expr = location !== void 0 ? {
+    kind,
+    name: [{ String: { sval: "=" } }],
+    lexpr: { ColumnRef: { fields, location } },
+    rexpr: createParamRef(paramNumber, location),
+    location
+  } : {
+    kind,
+    name: [{ String: { sval: "=" } }],
+    lexpr: { ColumnRef: { fields } },
+    rexpr: createParamRef(paramNumber)
   };
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
+  return { A_Expr: expr };
 }
-function handleJsonExtractExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectFunction",
-    function: "jsonExtract",
-    column: expr.field,
-    args: expr.path,
-    table: rootTable
+function createAnyExpr(columnName, paramNumber, tableName, location) {
+  const fields = tableName ? [{ String: { sval: tableName } }, { String: { sval: columnName } }] : [{ String: { sval: columnName } }];
+  const kind = "AEXPR_OP";
+  const anyCall = location !== void 0 ? {
+    funcname: [{ String: { sval: "any" } }],
+    args: [createParamRef(paramNumber, location)],
+    location
+  } : {
+    funcname: [{ String: { sval: "any" } }],
+    args: [createParamRef(paramNumber)]
   };
-  if (expr.mode) decision.jsonMode = expr.mode;
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
-}
-function handleJsonPathExtractExpression(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectFunction",
-    function: "jsonPathExtract",
-    column: expr.field,
-    args: [expr.path],
-    table: rootTable
+  const expr = location !== void 0 ? {
+    kind,
+    name: [{ String: { sval: "=" } }],
+    lexpr: { ColumnRef: { fields, location } },
+    rexpr: { FuncCall: anyCall },
+    location
+  } : {
+    kind,
+    name: [{ String: { sval: "=" } }],
+    lexpr: { ColumnRef: { fields } },
+    rexpr: { FuncCall: anyCall }
   };
-  if (expr.mode) decision.jsonMode = expr.mode;
-  if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
+  return { A_Expr: expr };
 }
-function handleCustomExpressionSelect(expr, rootTable, decisions) {
-  const decision = {
-    type: "selectCustomExpression",
-    expressionIntent: expr,
-    table: rootTable
-  };
-  const explicitAlias = expr.as;
-  if (explicitAlias) {
-    decision.alias = explicitAlias;
-  } else if (expr.kind === "cast") {
-    const inner = expr.expr;
-    if (inner?.kind === "ref") {
-      const col = inner.column;
-      const dotIdx = col.lastIndexOf(".");
-      decision.alias = dotIdx !== -1 ? col.slice(dotIdx + 1) : col;
+function collectAndValidateParamRefs(node) {
+  const paramRefs = [];
+  function traverse(n, path) {
+    if (n === null || n === void 0) return;
+    if (typeof n === "object") {
+      const obj = n;
+      if ("ParamRef" in obj && obj.ParamRef !== void 0) {
+        paramRefs.push({
+          paramRef: obj.ParamRef,
+          path
+        });
+      }
+      for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value)) {
+          value.forEach((item, index) => {
+            traverse(item, `${path}.${key}[${index}]`);
+          });
+        } else if (typeof value === "object") {
+          traverse(value, `${path}.${key}`);
+        }
+      }
     }
   }
-  decisions.push(decision);
+  traverse(node, "root");
+  const validationResults = paramRefs.map((p) => validateParamRef(p.paramRef));
+  const allValid = validationResults.every((r) => r.valid);
+  return { paramRefs, validationResults, allValid };
 }
-var EXPRESSION_HANDLERS;
-var init_select_expression_handlers = __esm({
-  "src/select-expression-handlers.ts"() {
+var init_param_ref = __esm({
+  "src/param-ref.ts"() {
     "use strict";
-    EXPRESSION_HANDLERS = {
-      column: (expr, rootTable, decisions) => handleColumnExpression(expr, rootTable, decisions),
-      columnAlias: (expr, rootTable, decisions) => handleColumnExpression(expr, rootTable, decisions),
-      aggregate: (expr, rootTable, decisions, applyFilter) => handleAggregateExpression(expr, rootTable, decisions, applyFilter),
-      coalesce: (expr, rootTable, decisions) => handleCoalesceExpression(expr, rootTable, decisions),
-      raw: (expr, rootTable, decisions) => handleRawExpression(expr, rootTable, decisions),
-      window: (expr, rootTable, decisions) => handleWindowExpression(expr, rootTable, decisions),
-      case: (expr, rootTable, decisions, applyFilter, convertCondition) => handleCaseExpression(
-        expr,
-        rootTable,
-        decisions,
-        applyFilter,
-        convertCondition
-      ),
-      relationColumn: (expr, rootTable, decisions) => handleRelationColumnExpression(expr, rootTable, decisions),
-      // pseudoColumn: intentional no-op — planner hints, not SQL
-      arithmetic: (expr, rootTable, decisions) => handleArithmeticExpression(expr, rootTable, decisions),
-      jsonExtract: (expr, rootTable, decisions) => handleJsonExtractExpression(expr, rootTable, decisions),
-      jsonPathExtract: (expr, rootTable, decisions) => handleJsonPathExtractExpression(expr, rootTable, decisions),
-      // Custom expression types — produce 'selectCustomExpression' decisions
-      literal: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
-      customOp: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
-      customFn: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
-      ref: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
-      param: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
-      cast: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
-      unary: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions)
-    };
   }
 });
 
-// src/intent-to-decisions.ts
-function intentToDecisions(intent, rootTable) {
-  const decisions = [];
-  if (intent.select) {
-    decisions.push(...convertSelect(intent.select, rootTable));
-  } else {
-    decisions.push({ type: "select", column: "*", table: rootTable });
+// src/handlers/expression/case-value.ts
+function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler) {
+  if (value === null || value === void 0) {
+    return nullConstNode();
   }
-  if (intent.where) {
-    decisions.push(...convertWhere(intent.where, rootTable));
+  if (typeof value === "string") {
+    return columnRef(value, alias, schema, naming);
   }
-  if (intent.orderBy && intent.orderBy.length > 0) {
-    for (const order of intent.orderBy) {
-      decisions.push(convertOrderBy(order, rootTable));
-    }
+  if (typeof value !== "object") {
+    const idx = ++state.paramIndex;
+    state.parameters.push(value);
+    return createParamRef(idx);
   }
-  if (intent.groupBy && intent.groupBy.length > 0) {
-    for (const col of intent.groupBy) {
-      decisions.push({ type: "groupBy", column: col, table: rootTable });
+  const expr = value;
+  switch (expr.kind) {
+    case "literal":
+      if (expr.value === null || expr.value === void 0)
+        return nullConstNode();
+      if (typeof expr.value === "boolean")
+        return booleanConstNode(expr.value);
+      if (typeof expr.value === "number") {
+        if (Number.isInteger(expr.value))
+          return integerNode(expr.value);
+        return floatNode(String(expr.value));
+      }
+      {
+        const idx = ++state.paramIndex;
+        state.parameters.push(expr.value);
+        return createParamRef(idx);
+      }
+    case "column":
+      return columnRef(expr.column, alias, schema, naming);
+    case "arithmetic": {
+      const left = resolveCaseValue(
+        expr.left,
+        alias,
+        schema,
+        naming,
+        state,
+        nestedCaseHandler
+      );
+      const right = resolveCaseValue(
+        expr.right,
+        alias,
+        schema,
+        naming,
+        state,
+        nestedCaseHandler
+      );
+      return {
+        A_Expr: {
+          kind: "AEXPR_OP",
+          name: [{ String: { sval: expr.operator } }],
+          lexpr: left,
+          rexpr: right
+        }
+      };
     }
-  }
-  if (intent.having) {
-    const havingDecisions = convertWhere(intent.having, rootTable);
-    for (const d of havingDecisions) {
-      decisions.push({ ...d, type: "having" });
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: intentional — no nested handler → parameterize via default
+    case "case":
+      if (nestedCaseHandler) {
+        return nestedCaseHandler(expr);
+      }
+    // falls through
+    default: {
+      const idx = ++state.paramIndex;
+      state.parameters.push(value);
+      return createParamRef(idx);
     }
   }
-  if (intent.distinctOn && intent.distinctOn.length > 0) {
-    decisions.push({ type: "distinctOn", columns: intent.distinctOn });
-  } else if (intent.distinct) {
-    decisions.push({ type: "distinct" });
-  }
-  if (intent.limit !== void 0) {
-    decisions.push({ type: "limit", limit: intent.limit });
-  }
-  if (intent.offset !== void 0) {
-    decisions.push({ type: "offset", offset: intent.offset });
+}
+var init_case_value = __esm({
+  "src/handlers/expression/case-value.ts"() {
+    "use strict";
+    init_ast_helpers();
+    init_param_ref();
   }
-  return decisions;
+});
+
+// src/handlers/expression/custom.ts
+import { validateTypeName } from "@dbsp/core";
+function registerWhereDispatcherFactory(factory) {
+  _whereDispatcherFactory = factory;
 }
-function applyFilterCondition(decision, filter, rootTable) {
-  if (filter) {
-    const filterDecision = convertWhereCondition(filter, rootTable);
-    if (filterDecision) decision.filterCondition = filterDecision;
+function _createWhereDispatcher() {
+  if (!_whereDispatcherFactory) {
+    throw new Error(
+      "compileExpressionIntent (case): WHERE dispatcher not initialized. Ensure compile-where.ts is imported before any CASE expression is compiled."
+    );
   }
+  return _whereDispatcherFactory();
 }
-function convertSelect(select, rootTable) {
-  const selectType = "type" in select ? select.type : void 0;
-  if ("all" in select && select.all === true) {
-    return [{ type: "select", column: "*", table: rootTable }];
+function assertSafeOperator(op3, opts) {
+  if (typeof op3 !== "string") {
+    throw new Error(
+      `Invalid operator: expected a string, got ${typeof op3}. Operator must be a plain string value.`
+    );
   }
-  if (selectType === "fields" && "fields" in select) {
-    return select.fields.map((field) => ({
-      type: "select",
-      column: field,
-      table: rootTable
-    }));
+  if (!op3) {
+    throw new Error(`Invalid operator "${op3}". Operator must not be empty.`);
   }
-  if (selectType === "expressions" && "columns" in select) {
-    const decisions = [];
-    const columns = select.columns;
-    for (const exprUnknown of columns) {
-      const expr = exprUnknown;
-      const handler = EXPRESSION_HANDLERS[expr.kind];
-      if (handler) {
-        handler(
-          expr,
-          rootTable,
-          decisions,
-          applyFilterCondition,
-          convertWhereCondition
+  const SYMBOLIC_RE = /^[-+*/<>=~!@#%^&|?]+$/;
+  const isSymbolic = SYMBOLIC_RE.test(op3);
+  const isAllowedWord = opts?.allowWords?.some((w) => w.toLowerCase() === op3.toLowerCase()) ?? false;
+  if (!isSymbolic && !isAllowedWord) {
+    throw new Error(
+      `Invalid operator "${op3}". Operator must consist only of symbolic characters (e.g. <=>, <->, @@, @>, <@, &&, ||, ~)` + (opts?.allowWords?.length ? ` or one of the allowed words: ${opts.allowWords.join(", ")}.` : ".")
+    );
+  }
+  if (op3.includes("--") || op3.includes("/*") || op3.includes("*/")) {
+    throw new Error(
+      `Invalid operator "${op3}" \u2014 must not contain SQL comment sequences (-- /* */).`
+    );
+  }
+}
+function compileExpressionIntent(intent, ctx, state) {
+  const kind = intent.kind;
+  switch (kind) {
+    case "customOp": {
+      const i = intent;
+      const operator = i.operator;
+      assertSafeOperator(operator);
+      const leftNode = compileExpressionIntent(i.left, ctx, state);
+      const rightNode = compileExpressionIntent(i.right, ctx, state);
+      return {
+        A_Expr: {
+          kind: "AEXPR_OP",
+          name: [{ String: { sval: operator } }],
+          lexpr: leftNode,
+          rexpr: rightNode
+        }
+      };
+    }
+    case "customFn": {
+      const i = intent;
+      const nameParts = i.name.split(".");
+      const argNodes = i.args.map(
+        (arg) => compileExpressionIntent(arg, ctx, state)
+      );
+      const orderByNodes = i.aggOrderBy && i.aggOrderBy.length > 0 ? i.aggOrderBy.map((ob) => {
+        const colNode = columnRef(
+          ob.field,
+          void 0,
+          void 0,
+          ctx.naming
         );
+        return sortBy(colNode, ob.direction === "desc" ? "DESC" : "ASC");
+      }) : void 0;
+      return funcCall(nameParts, argNodes, {
+        ...orderByNodes ? { orderBy: orderByNodes } : {}
+      });
+    }
+    case "ref": {
+      const i = intent;
+      const dotIdx = i.column.indexOf(".");
+      if (dotIdx !== -1) {
+        const table = i.column.slice(0, dotIdx);
+        const col = i.column.slice(dotIdx + 1);
+        return columnRef(col, table, void 0, ctx.naming);
       }
+      return columnRef(i.column, void 0, void 0, ctx.naming);
     }
-    return decisions;
-  }
-  if ("aggregates" in select) {
-    const decisions = [];
-    if (select.fields) {
-      for (const field of select.fields) {
-        decisions.push({ type: "select", column: field, table: rootTable });
+    case "param": {
+      const i = intent;
+      const idx = ++state.paramIndex;
+      state.parameters.push(i.value);
+      return createParamRef(idx);
+    }
+    case "cast": {
+      const i = intent;
+      const typeName = i.typeName;
+      if (typeof typeName !== "string") {
+        throw new Error(
+          `cast(): typeName must be a plain string, got ${typeof typeName}.`
+        );
       }
+      validateTypeName(typeName);
+      const argNode = compileExpressionIntent(i.expr, ctx, state);
+      return typeCast(argNode, typeName);
     }
-    for (const agg of select.aggregates) {
-      const aggDecision = {
-        type: "selectFunction",
-        function: agg.function === "count" && agg.field === "*" ? "count" : agg.function,
-        column: agg.field ?? "*",
-        table: rootTable
-      };
-      if (agg.as) {
-        aggDecision.alias = agg.as;
+    case "literal": {
+      const i = intent;
+      if (i.value === null || i.value === void 0) {
+        return nullConstNode();
       }
-      applyFilterCondition(aggDecision, agg.filter, rootTable);
-      decisions.push(aggDecision);
+      if (typeof i.value === "boolean") {
+        return booleanConstNode(i.value);
+      }
+      if (typeof i.value === "number") {
+        if (!Number.isFinite(i.value)) {
+          throw new Error(
+            `literal(): numeric value must be finite; got ${i.value}. Use param() for computed values.`
+          );
+        }
+        if (Number.isInteger(i.value)) {
+          return integerNode(i.value);
+        }
+        return floatNode(String(i.value));
+      }
+      if (typeof i.value === "string") {
+        return {
+          A_Const: { sval: { sval: i.value } }
+        };
+      }
+      throw new Error(
+        `literal(): unsupported value type "${typeof i.value}". Only null, boolean, number, and string are allowed. Use param() to bind computed or user-supplied values.`
+      );
     }
-    return decisions;
-  }
-  return [{ type: "select", column: "*", table: rootTable }];
-}
-function convertWhere(where, rootTable) {
-  const decision = convertWhereCondition(where, rootTable);
-  return decision ? [decision] : [];
-}
-function assertNoUnsupportedSubqueryModifiers(subquery, context) {
-  const unsupported = [];
-  if (subquery.groupBy && subquery.groupBy.length > 0)
-    unsupported.push("GROUP BY");
-  if (subquery.having) unsupported.push("HAVING");
-  if (subquery.offset != null) unsupported.push("OFFSET");
-  if (subquery.distinct) unsupported.push("DISTINCT");
-  if (subquery.distinctOn && subquery.distinctOn.length > 0)
-    unsupported.push("DISTINCT ON");
-  if (subquery.include && subquery.include.length > 0)
-    unsupported.push("include (relation hydration)");
-  if (subquery.joins && subquery.joins.length > 0) unsupported.push("joins");
-  if (subquery.existsWrap) unsupported.push("existsWrap");
-  if (subquery.lock) unsupported.push("lock");
-  if (subquery.batchValuesSource) unsupported.push("batchValuesSource");
-  if (context === "rawExists" || context === "scalar-direct") {
-    if (subquery.limit != null) unsupported.push("LIMIT");
-  }
-  if (context === "rawExists" || context === "scalar-direct") {
-    if (subquery.orderBy && subquery.orderBy.length > 0) {
-      unsupported.push("ORDER BY");
+    case "unary": {
+      const i = intent;
+      const operator = i.operator;
+      assertSafeOperator(operator, { allowWords: ["NOT"] });
+      const operandNode = compileExpressionIntent(i.operand, ctx, state);
+      return {
+        A_Expr: {
+          kind: "AEXPR_OP",
+          name: [{ String: { sval: operator } }],
+          rexpr: operandNode
+        }
+      };
     }
-  } else if (subquery.orderBy && subquery.orderBy.length > 0) {
-    const hasExpressionSort = subquery.orderBy.some(
-      (o) => !("field" in o) || o.field == null
-    );
-    if (hasExpressionSort)
-      unsupported.push(
-        "orderBy with expression (only field-based ORDER BY is supported)"
-      );
-  }
-  if (context === "IN") {
-    const select = subquery.select;
-    if (!select) {
-      unsupported.push(
-        "missing select (IN subquery must project exactly one named column)"
-      );
-    } else if (select.type === "aggregate") {
-      unsupported.push(
-        "aggregate SELECT (use a scalar subquery comparison instead)"
-      );
-    } else if (select.type === "expressions") {
-      unsupported.push("expressions SELECT (not supported in IN subquery)");
-    } else if (select.type === "all") {
-      unsupported.push(
-        "SELECT * / all (IN subquery must project exactly one named column)"
-      );
-    } else if (select.type === "fields" || Array.isArray(select.fields) || // Also catch the typeless `{ fields: undefined | null }` shape: the
-    // `fields` key is present (triggering isSelectWithFields in the compiler)
-    // but the value is not a non-empty array.  Without this branch,
-    // `{ fields: undefined }` falls through all checks and the compiler
-    // silently falls back to SELECT *, producing wrong SQL.
-    // Guard: `in` operator crashes on primitives; a string select like 'id'
-    // is a valid single-column selector — only check for the `fields` key on
-    // actual objects.
-    typeof select === "object" && select !== null && "fields" in select) {
-      if (!select.fields || select.fields.length === 0) {
-        unsupported.push(
-          "empty fields list (IN subquery must project exactly one named column)"
+    case "namedArg": {
+      const nae = intent;
+      const name = nae.name;
+      if (typeof name !== "string") {
+        throw new Error(
+          `namedArg(): name must be a plain string, got ${typeof name}.`
         );
-      } else if (select.fields.length > 1) {
-        unsupported.push(
-          `multi-field projection [${select.fields.join(", ")}] (IN subquery must project exactly one named column \u2014 use a single field)`
+      }
+      validateIdentifier(name, "alias");
+      const argNode = compileExpressionIntent(nae.value, ctx, state);
+      return {
+        NamedArgExpr: {
+          arg: argNode,
+          name,
+          argnumber: -1
+        }
+      };
+    }
+    case "star":
+      return {
+        ColumnRef: { fields: [{ A_Star: {} }] }
+      };
+    case "array": {
+      const ae = intent;
+      const elements = ae.elements.map(
+        (el) => compileExpressionIntent(el, ctx, state)
+      );
+      return { A_ArrayExpr: { elements } };
+    }
+    case "subquery": {
+      const sq = intent;
+      if (!ctx.compileSubquery) {
+        throw new Error(
+          "compileExpressionIntent: 'subquery' expression kind requires ctx.compileSubquery to be set. Use asExpr() only in .columns() context, not in standalone expressions."
         );
-      } else if (typeof select.fields[0] !== "string") {
-        unsupported.push(
-          `non-string field element ${JSON.stringify(select.fields[0])} (IN subquery fields must contain a plain column name string)`
+      }
+      const { ast: innerAst, parameters: innerParams } = ctx.compileSubquery(
+        sq.query,
+        state.paramIndex
+      );
+      for (const p of innerParams) {
+        state.parameters.push(p);
+      }
+      state.paramIndex += innerParams.length;
+      return {
+        SubLink: {
+          subLinkType: "EXPR_SUBLINK",
+          subselect: innerAst
+        }
+      };
+    }
+    case "relationColumn": {
+      const rc = intent;
+      const alias = state.aliases.get(rc.relation) ?? rc.relation;
+      return columnRef(rc.column, alias, void 0, ctx.naming);
+    }
+    case "case": {
+      const dispatch = _createWhereDispatcher();
+      const caseIntent = intent;
+      if (!caseIntent.when || caseIntent.when.length === 0) {
+        throw new Error("CASE expression requires at least one WHEN clause");
+      }
+      const caseArgs = caseIntent.when.map((branch) => {
+        const whenNode = dispatch(
+          branch.condition,
+          ctx,
+          state
         );
+        const thenNode = compileExpressionIntent(branch.result, ctx, state);
+        return {
+          CaseWhen: { expr: whenNode, result: thenNode }
+        };
+      });
+      let defresult;
+      if (caseIntent.else !== void 0) {
+        defresult = compileExpressionIntent(caseIntent.else, ctx, state);
       }
+      return {
+        CaseExpr: {
+          args: caseArgs,
+          ...defresult !== void 0 ? { defresult } : {}
+        }
+      };
     }
-  }
-  const isScalarContext = context === "scalar" || context === "scalar-direct";
-  if (isScalarContext) {
-    const select = subquery.select;
-    if (select?.type === "expressions") {
-      unsupported.push("expressions SELECT (not supported in scalar subquery)");
-    } else if (select?.type === "fields" && select.fields != null && select.fields.length > 1) {
-      unsupported.push(
-        `multi-field projection [${select.fields.join(", ")}] (scalar subquery must project exactly one column \u2014 use a single field)`
-      );
-    } else if (select?.type === "aggregate" && select.aggregates != null && select.aggregates.length > 1) {
-      unsupported.push(
-        `multi-aggregate projection (scalar subquery must project exactly one column \u2014 use a single aggregate)`
+    default: {
+      throw new Error(
+        `compileExpressionIntent: unsupported expression kind '${kind}'`
       );
     }
   }
-  if (unsupported.length > 0) {
-    const label = context === "IN" ? "IN" : context === "rawExists" ? "rawExists" : "scalar";
-    throw new Error(
-      `${label} subquery with ${unsupported.join(", ")} is not supported \u2014 it would silently change which rows match; restructure the query or use a CTE.`
-    );
-  }
-}
-function isOuterRef(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value;
-  return v.kind === "ref" && v.outer === true;
 }
-function containsOuterRef(where) {
-  if (!where || typeof where !== "object") return false;
-  const w = where;
-  if (isOuterRef(w)) return true;
-  for (const value of Object.values(w)) {
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (containsOuterRef(item)) return true;
+var _whereDispatcherFactory, customExpressionHandler;
+var init_custom = __esm({
+  "src/handlers/expression/custom.ts"() {
+    "use strict";
+    init_ast_helpers();
+    init_param_ref();
+    init_validate();
+    customExpressionHandler = {
+      types: [
+        "customOp",
+        "customFn",
+        "ref",
+        "param",
+        "cast",
+        "unary",
+        "customExpression"
+      ],
+      compile(decision, ctx, state) {
+        const expressionIntent = decision.expressionIntent;
+        return compileExpressionIntent(expressionIntent, ctx, state);
       }
-    } else if (typeof value === "object" && value !== null) {
-      if (containsOuterRef(value)) return true;
-    }
+    };
   }
-  return false;
-}
-function convertComparison(cond, rootTable) {
-  const rawValue = cond.value;
-  const resolvedValue = isOuterRef(rawValue) ? {
-    kind: "fieldRef",
-    scope: "outer",
-    column: rawValue.column
-  } : rawValue;
-  const result = {
-    type: "where",
-    column: cond.field,
-    operator: cond.operator,
-    value: resolvedValue,
-    table: rootTable
-  };
-  if (cond.jsonPath) result.jsonPath = cond.jsonPath;
-  if (cond.jsonMode) result.jsonMode = cond.jsonMode;
-  return result;
-}
-function convertLike(cond, rootTable) {
-  const result = {
-    type: "where",
-    column: cond.field,
-    operator: cond.caseInsensitive ? "ilike" : "like",
-    value: cond.pattern,
+});
+
+// src/select-expression-handlers.ts
+function handleColumnExpression(expr, rootTable, decisions) {
+  const decision = {
+    type: "select",
+    column: expr.column,
     table: rootTable
   };
-  if (cond.escape !== void 0) result.escape = cond.escape;
-  return result;
+  const alias = expr.as ?? expr.alias;
+  if (alias) decision.alias = alias;
+  decisions.push(decision);
 }
-function convertIn(cond, rootTable) {
-  const rawSubquery = cond.subquery;
-  if (rawSubquery) {
-    assertNoUnsupportedSubqueryModifiers(rawSubquery, "IN");
-    const selectField = rawSubquery.select;
-    const selectColumn = selectField && "fields" in selectField && Array.isArray(selectField.fields) ? selectField.fields[0] ?? "*" : "*";
-    const subConditions = rawSubquery.where ? (() => {
-      const converted = convertWhereCondition(
-        rawSubquery.where,
-        rawSubquery.from
-      );
-      return converted ? [converted] : [];
-    })() : [];
-    const rawLimit = rawSubquery.limit;
-    const rawOrderBy = rawSubquery.orderBy;
-    return {
-      type: "where",
-      column: cond.field,
-      operator: cond.not ? "notInSubquery" : "inSubquery",
-      targetTable: rawSubquery.from,
-      selectColumn,
-      conditions: subConditions,
-      table: rootTable,
-      // Provenance: original QueryIntent for validation in buildPredicateSubquerySelect
-      subqueryIntent: rawSubquery,
-      ...rawLimit != null && { limit: rawLimit },
-      ...rawOrderBy && {
-        orderBy: rawOrderBy.map((o) => ({
-          field: o.field,
-          direction: o.direction?.toLowerCase() ?? "asc"
-        }))
-      }
-    };
-  }
-  return {
-    type: "where",
-    column: cond.field,
-    operator: cond.not ? "notIn" : "in",
-    value: cond.values,
-    table: rootTable
-  };
-}
-function convertNull(cond, rootTable) {
-  return {
-    type: "where",
-    column: cond.field,
-    operator: cond.operator,
-    table: rootTable
-  };
-}
-function convertRange(cond, rootTable) {
-  const rangeOperator = cond.operator;
-  const col = cond.field;
-  if (rangeOperator === "contains" || rangeOperator === "containedBy" || rangeOperator === "overlaps") {
-    return {
-      type: "where",
-      column: col,
-      operator: rangeOperator,
-      value: cond.value,
-      table: rootTable
-    };
-  }
-  if (rangeOperator === "between") {
-    const rangeVal = cond.value;
-    return {
-      type: "where",
-      column: col,
-      operator: "between",
-      value: [rangeVal.lower, rangeVal.upper],
-      table: rootTable
-    };
-  }
-  if (cond.gte !== void 0 && cond.lte !== void 0) {
-    return {
-      type: "where",
-      column: col,
-      operator: "between",
-      value: [cond.gte, cond.lte],
-      table: rootTable
-    };
-  }
-  if (cond.gte !== void 0) {
-    return {
-      type: "where",
-      column: col,
-      operator: "gte",
-      value: cond.gte,
-      table: rootTable
-    };
-  }
-  if (cond.gt !== void 0) {
-    return {
-      type: "where",
-      column: col,
-      operator: "gt",
-      value: cond.gt,
+function handleAggregateExpression(expr, rootTable, decisions, applyFilter) {
+  const aggFunc = expr.function;
+  const aggField = expr.field;
+  const aggAs = expr.as;
+  const aggDistinct = expr.distinct;
+  const aggFilter = expr.filter;
+  if (aggFunc === "count" && !aggField) {
+    const decision = {
+      type: "selectFunction",
+      function: "count",
+      column: "*",
       table: rootTable
     };
-  }
-  if (cond.lte !== void 0) {
-    return {
-      type: "where",
-      column: col,
-      operator: "lte",
-      value: cond.lte,
+    if (aggAs) decision.alias = aggAs;
+    applyFilter(decision, aggFilter, rootTable);
+    decisions.push(decision);
+  } else if (aggFunc === "count" && aggDistinct && aggField) {
+    const decision = {
+      type: "selectFunction",
+      function: "countDistinct",
+      column: aggField,
       table: rootTable
     };
-  }
-  if (cond.lt !== void 0) {
-    return {
-      type: "where",
-      column: col,
-      operator: "lt",
-      value: cond.lt,
+    if (aggAs) decision.alias = aggAs;
+    applyFilter(decision, aggFilter, rootTable);
+    decisions.push(decision);
+  } else {
+    const decision = {
+      type: "selectFunction",
+      function: aggFunc,
       table: rootTable
     };
+    if (aggField) decision.column = aggField;
+    if (aggAs) decision.alias = aggAs;
+    applyFilter(decision, aggFilter, rootTable);
+    decisions.push(decision);
   }
-  return null;
 }
-function convertLogicalGroup(cond, rootTable, decisionType) {
-  const subDecisions = [];
-  for (const sub of cond.conditions) {
-    const subDecision = convertWhereCondition(sub, rootTable);
-    if (subDecision) subDecisions.push(subDecision);
-  }
-  if (subDecisions.length === 0) return null;
-  return { type: decisionType, conditions: subDecisions };
+function handleCoalesceExpression(expr, rootTable, decisions) {
+  const decision = {
+    type: "selectFunction",
+    function: "coalesce",
+    args: expr.fields,
+    table: rootTable
+  };
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
 }
-function convertNot(cond, rootTable) {
-  const subDecision = convertWhereCondition(
-    cond.condition,
-    rootTable
-  );
-  if (!subDecision) return null;
-  return { type: "whereNot", conditions: [subDecision] };
+function handleRawExpression(expr, rootTable, decisions) {
+  const decision = {
+    type: "selectFunction",
+    function: "raw",
+    args: [expr.sql],
+    table: rootTable
+  };
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
 }
-function convertExistsLike(cond, operator) {
-  const targetTable = cond.relation;
-  const subDecisions = cond.where ? convertWhere(cond.where, targetTable) : [];
-  const base = { type: "where", operator, targetTable };
-  return subDecisions.length > 0 ? { ...base, conditions: subDecisions } : base;
+function handleWindowExpression(expr, rootTable, decisions) {
+  const windowFunc = expr.function;
+  const windowAlias = expr.alias;
+  const windowField = expr.field;
+  const over = expr.over;
+  const decision = {
+    type: "selectWindow",
+    function: windowFunc,
+    alias: windowAlias,
+    table: rootTable
+  };
+  if (windowField) decision.field = windowField;
+  if (over.partitionBy) decision.partitionBy = over.partitionBy;
+  if (over.orderBy) decision.orderBy = over.orderBy;
+  const windowOffset = expr.offset;
+  const windowDefault = expr.defaultValue;
+  if (windowOffset !== void 0) decision.args = [windowOffset];
+  if (windowDefault !== void 0) decision.value = windowDefault;
+  decisions.push(decision);
 }
-function convertSubquery(cond) {
-  const field = cond.field;
-  const operator = cond.operator;
-  const subquery = cond.subquery;
-  if (!subquery || !field) return null;
-  assertNoUnsupportedSubqueryModifiers(subquery, "scalar");
-  if (subquery.where && containsOuterRef(subquery.where)) {
-    throw new Error(
-      'scalar subquery with correlated outerRef() is not yet supported \u2014 use exists("relation", { where: ... }) when a schema relation exists, or restructure the query to avoid the correlation.'
-    );
-  }
-  const targetTable = subquery.from;
-  let selectColumn = "*";
-  let aggregate;
-  const select = subquery.select;
-  if (select) {
-    if ("type" in select && select.type === "aggregate") {
-      const agg = select.aggregates?.[0];
-      if (agg) {
-        aggregate = agg.function;
-        selectColumn = agg.field ?? "*";
-      }
-    } else if ("fields" in select && select.fields?.length) {
-      selectColumn = select.fields[0];
-    }
-  }
-  const subConditions = [];
-  if (subquery.where) {
-    const innerWhere = convertWhereCondition(
-      subquery.where,
-      targetTable
-    );
-    if (innerWhere) subConditions.push(innerWhere);
+function handleCaseExpression(expr, rootTable, decisions, _applyFilter, convertCondition) {
+  const whenClauses = expr.when;
+  const conditions = whenClauses.map((wc) => ({
+    when: convertCondition(wc.condition, rootTable),
+    // biome-ignore lint/suspicious/noThenProperty: intentional reserved word in decision object
+    then: wc.result
+  }));
+  const decision = {
+    type: "selectExpression",
+    expressionType: "case",
+    table: rootTable
+  };
+  decision.conditions = conditions;
+  if (expr.else) {
+    decision.value = expr.else;
   }
-  const rawLimit = subquery.limit;
-  const rawOrderBy = subquery.orderBy;
-  const opMap = {
-    eq: "=",
-    neq: "!=",
-    gt: ">",
-    gte: ">=",
-    lt: "<",
-    lte: "<="
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
+}
+function handleRelationColumnExpression(expr, rootTable, decisions) {
+  const decision = {
+    type: "selectRelationColumn",
+    relation: expr.relation,
+    column: expr.column ?? "*",
+    table: rootTable
   };
-  return {
-    type: "where",
-    column: field,
-    operator: "scalarSubquery",
-    targetTable,
-    selectColumn,
-    subqueryOperator: opMap[operator] ?? "=",
-    // Provenance: original QueryIntent for validation in buildPredicateSubquerySelect
-    subqueryIntent: subquery,
-    ...aggregate && { aggregate },
-    ...subConditions.length > 0 && { conditions: subConditions },
-    ...rawLimit != null && { limit: rawLimit },
-    ...rawOrderBy && rawOrderBy.length > 0 && {
-      orderBy: rawOrderBy.map((o) => ({
-        field: o.field,
-        direction: o.direction?.toLowerCase() ?? "asc"
-      }))
-    }
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
+}
+function handleArithmeticExpression(expr, rootTable, decisions) {
+  const decision = {
+    type: "selectArithmetic",
+    operator: expr.operator,
+    args: [expr.left, expr.right],
+    table: rootTable
   };
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
 }
-function convertWhereCondition(condition, rootTable) {
-  const cond = condition;
-  switch (cond.kind) {
-    case "comparison":
-      return convertComparison(cond, rootTable);
-    case "like":
-      return convertLike(cond, rootTable);
-    case "in":
-      return convertIn(cond, rootTable);
-    case "null":
-      return convertNull(cond, rootTable);
-    case "range":
-      return convertRange(cond, rootTable);
-    case "and":
-      return convertLogicalGroup(cond, rootTable, "whereAnd");
-    case "or":
-      return convertLogicalGroup(cond, rootTable, "whereOr");
-    case "not":
-      return convertNot(cond, rootTable);
-    case "exists":
-      return convertExistsLike(cond, "exists");
-    case "notExists":
-      return convertExistsLike(cond, "notExists");
-    case "relationFilter": {
-      const mode = cond.mode || "some";
-      const operator = mode === "none" ? "notExists" : mode === "every" ? "every" : "exists";
-      return convertExistsLike(cond, operator);
-    }
-    case "subquery":
-      return convertSubquery(cond);
-    case "rawExists":
-    case "rawNotExists": {
-      const sub = cond.subquery;
-      if (!sub) {
-        throw new Error(
-          `${cond.kind}: missing subquery \u2014 pass the result of subquery(table).select(...) or a builder with buildIntent()`
-        );
-      }
-      assertNoUnsupportedSubqueryModifiers(sub, "rawExists");
-      if (sub.where && containsOuterRef(sub.where)) {
-        throw new Error(
-          `${cond.kind}: correlated subqueries (outerRef inside the inner WHERE) are not yet supported. Workaround: use exists("relation", { where: ... }) when a schema relation exists, or wait for the rawExists correlation pipeline (tracked in TODO).`
-        );
-      }
-      return {
-        type: "where",
-        operator: cond.kind,
-        // Reuse expressionIntent (already present on PlanDecision) to carry the
-        // inner QueryIntent; the rawExistsHandler discriminates by operator name.
-        expressionIntent: sub,
-        table: rootTable
-      };
-    }
-    case "jsonContains":
-      return {
-        type: "where",
-        column: cond.field,
-        operator: cond.reversed ? "jsonContainedBy" : "jsonContains",
-        value: cond.value,
-        table: rootTable
-      };
-    case "any":
-      return {
-        type: "where",
-        column: cond.field,
-        operator: "any",
-        values: cond.values,
-        table: rootTable
-      };
-    case "jsonExists":
-      return {
-        type: "where",
-        column: cond.field,
-        operator: "jsonExists",
-        value: cond.key,
-        table: rootTable
-      };
-    case "expression":
-      return {
-        type: "where",
-        operator: "expression",
-        expressionIntent: cond.expr,
-        value: cond.value,
-        subqueryOperator: cond.operator,
-        table: rootTable
-      };
-    default:
-      return null;
-  }
+function handleJsonExtractExpression(expr, rootTable, decisions) {
+  const decision = {
+    type: "selectFunction",
+    function: "jsonExtract",
+    column: expr.field,
+    args: expr.path,
+    table: rootTable
+  };
+  if (expr.mode) decision.jsonMode = expr.mode;
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
 }
-function convertOrderBy(order, rootTable) {
-  const direction = order.direction === "desc" ? "DESC" : "ASC";
-  const nulls = order.nulls ? order.nulls === "first" ? "FIRST" : "LAST" : void 0;
-  if (order.expression) {
-    const base = {
-      type: "orderBy",
-      expressionIntent: order.expression,
-      direction,
-      table: rootTable
-    };
-    if (nulls) {
-      return { ...base, nulls };
-    }
-    return base;
-  }
+function handleJsonPathExtractExpression(expr, rootTable, decisions) {
   const decision = {
-    type: "orderBy",
-    direction,
-    table: rootTable,
-    // field is optional in OrderByIntent after expression extension (exactOptionalPropertyTypes)
-    ...order.field ? { column: order.field } : {}
+    type: "selectFunction",
+    function: "jsonPathExtract",
+    column: expr.field,
+    args: [expr.path],
+    table: rootTable
   };
-  if (nulls) {
-    return { ...decision, nulls };
+  if (expr.mode) decision.jsonMode = expr.mode;
+  if (expr.as) decision.alias = expr.as;
+  decisions.push(decision);
+}
+function handleCustomExpressionSelect(expr, rootTable, decisions) {
+  const decision = {
+    type: "selectCustomExpression",
+    expressionIntent: expr,
+    table: rootTable
+  };
+  const explicitAlias = expr.as;
+  if (explicitAlias) {
+    decision.alias = explicitAlias;
+  } else if (expr.kind === "cast") {
+    const inner = expr.expr;
+    if (inner?.kind === "ref") {
+      const col = inner.column;
+      const dotIdx = col.lastIndexOf(".");
+      decision.alias = dotIdx !== -1 ? col.slice(dotIdx + 1) : col;
+    }
   }
-  return decision;
+  decisions.push(decision);
 }
-var init_intent_to_decisions = __esm({
-  "src/intent-to-decisions.ts"() {
+var EXPRESSION_HANDLERS;
+var init_select_expression_handlers = __esm({
+  "src/select-expression-handlers.ts"() {
     "use strict";
-    init_select_expression_handlers();
+    EXPRESSION_HANDLERS = {
+      column: (expr, rootTable, decisions) => handleColumnExpression(expr, rootTable, decisions),
+      columnAlias: (expr, rootTable, decisions) => handleColumnExpression(expr, rootTable, decisions),
+      aggregate: (expr, rootTable, decisions, applyFilter) => handleAggregateExpression(expr, rootTable, decisions, applyFilter),
+      coalesce: (expr, rootTable, decisions) => handleCoalesceExpression(expr, rootTable, decisions),
+      raw: (expr, rootTable, decisions) => handleRawExpression(expr, rootTable, decisions),
+      window: (expr, rootTable, decisions) => handleWindowExpression(expr, rootTable, decisions),
+      case: (expr, rootTable, decisions, applyFilter, convertCondition) => handleCaseExpression(
+        expr,
+        rootTable,
+        decisions,
+        applyFilter,
+        convertCondition
+      ),
+      relationColumn: (expr, rootTable, decisions) => handleRelationColumnExpression(expr, rootTable, decisions),
+      // pseudoColumn: intentional no-op — planner hints, not SQL
+      arithmetic: (expr, rootTable, decisions) => handleArithmeticExpression(expr, rootTable, decisions),
+      jsonExtract: (expr, rootTable, decisions) => handleJsonExtractExpression(expr, rootTable, decisions),
+      jsonPathExtract: (expr, rootTable, decisions) => handleJsonPathExtractExpression(expr, rootTable, decisions),
+      // Custom expression types — produce 'selectCustomExpression' decisions
+      literal: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
+      customOp: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
+      customFn: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
+      ref: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
+      param: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
+      cast: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions),
+      unary: (expr, rootTable, decisions) => handleCustomExpressionSelect(expr, rootTable, decisions)
+    };
   }
 });
 
-// src/handlers/types.ts
-function createCompilerState() {
-  return {
-    parameters: [],
-    paramIndex: 0,
-    ctes: /* @__PURE__ */ new Map(),
-    aliases: /* @__PURE__ */ new Map(),
-    joins: []
-  };
-}
-function isSqlExpression(value) {
-  return typeof value === "object" && value !== null && "sql" in value && typeof value.sql === "string";
+// src/intent-to-decisions.ts
+function intentToDecisions(intent, rootTable) {
+  const decisions = [];
+  if (intent.select) {
+    decisions.push(...convertSelect(intent.select, rootTable));
+  } else {
+    decisions.push({ type: "select", column: "*", table: rootTable });
+  }
+  if (intent.where) {
+    decisions.push(...convertWhere(intent.where, rootTable));
+  }
+  if (intent.orderBy && intent.orderBy.length > 0) {
+    for (const order of intent.orderBy) {
+      decisions.push(convertOrderBy(order, rootTable));
+    }
+  }
+  if (intent.groupBy && intent.groupBy.length > 0) {
+    for (const col of intent.groupBy) {
+      decisions.push({ type: "groupBy", column: col, table: rootTable });
+    }
+  }
+  if (intent.having) {
+    const havingDecisions = convertWhere(intent.having, rootTable);
+    for (const d of havingDecisions) {
+      decisions.push({ ...d, type: "having" });
+    }
+  }
+  if (intent.distinctOn && intent.distinctOn.length > 0) {
+    decisions.push({ type: "distinctOn", columns: intent.distinctOn });
+  } else if (intent.distinct) {
+    decisions.push({ type: "distinct" });
+  }
+  if (intent.limit !== void 0) {
+    decisions.push({ type: "limit", limit: intent.limit });
+  }
+  if (intent.offset !== void 0) {
+    decisions.push({ type: "offset", offset: intent.offset });
+  }
+  return decisions;
 }
-function isRangeValue(value) {
-  return typeof value === "object" && value !== null && ("lower" in value || "upper" in value);
-}
-function isParamRef(value) {
-  return typeof value === "object" && value !== null && "paramIndex" in value && typeof value.paramIndex === "number";
-}
-function isSelectWithFields(value) {
-  return typeof value === "object" && value !== null && "fields" in value && (Array.isArray(value.fields) || value.fields === void 0);
+function applyFilterCondition(decision, filter, rootTable) {
+  if (filter) {
+    const filterDecision = convertWhereCondition(filter, rootTable);
+    if (filterDecision) decision.filterCondition = filterDecision;
+  }
 }
-var COMPARISON_OPERATORS, PATTERN_OPERATORS, NULL_OPERATORS, COLLECTION_OPERATORS, LOGICAL_OPERATORS, ALL_OPERATORS;
-var init_types = __esm({
-  "src/handlers/types.ts"() {
-    "use strict";
-    COMPARISON_OPERATORS = {
-      EQ: "=",
-      NEQ: "!=",
-      LT: "<",
-      LTE: "<=",
-      GT: ">",
-      GTE: ">=",
-      // Aliases
-      eq: "=",
-      ne: "!=",
-      lt: "<",
-      lte: "<=",
-      gt: ">",
-      gte: ">="
-    };
-    PATTERN_OPERATORS = {
-      LIKE: "like",
-      ILIKE: "ilike",
-      NOT_LIKE: "notLike",
-      NOT_ILIKE: "notIlike"
-    };
-    NULL_OPERATORS = {
-      IS_NULL: "isNull",
-      IS_NOT_NULL: "isNotNull"
-    };
-    COLLECTION_OPERATORS = {
-      IN: "in",
-      NOT_IN: "notIn",
-      ANY: "any"
-    };
-    LOGICAL_OPERATORS = {
-      AND: "and",
-      OR: "or",
-      NOT: "not"
-    };
-    ALL_OPERATORS = {
-      ...COMPARISON_OPERATORS,
-      ...PATTERN_OPERATORS,
-      ...NULL_OPERATORS,
-      ...COLLECTION_OPERATORS,
-      ...LOGICAL_OPERATORS
-    };
+function convertSelect(select, rootTable) {
+  const selectType = "type" in select ? select.type : void 0;
+  if ("all" in select && select.all === true) {
+    return [{ type: "select", column: "*", table: rootTable }];
   }
-});
-
-// src/raw-expression-parser.ts
-function tokenise(input) {
-  const tokens = [];
-  let i = 0;
-  const src = input.trim();
-  while (i < src.length) {
-    const ch = src[i];
-    if (/\s/.test(ch)) {
-      i++;
-      continue;
-    }
-    if (/[0-9]/.test(ch)) {
-      let num = "";
-      while (i < src.length && /[0-9]/.test(src[i])) {
-        num += src[i++];
-      }
-      if (src[i] === "." && i + 1 < src.length && /[0-9]/.test(src[i + 1])) {
-        num += src[i++];
-        while (i < src.length && /[0-9]/.test(src[i])) {
-          num += src[i++];
-        }
-        tokens.push({ kind: "FLOAT", value: num });
-      } else {
-        tokens.push({ kind: "INT", value: num });
+  if (selectType === "fields" && "fields" in select) {
+    return select.fields.map((field) => ({
+      type: "select",
+      column: field,
+      table: rootTable
+    }));
+  }
+  if (selectType === "expressions" && "columns" in select) {
+    const decisions = [];
+    const columns = select.columns;
+    for (const exprUnknown of columns) {
+      const expr = exprUnknown;
+      const handler = EXPRESSION_HANDLERS[expr.kind];
+      if (handler) {
+        handler(
+          expr,
+          rootTable,
+          decisions,
+          applyFilterCondition,
+          convertWhereCondition
+        );
       }
-      continue;
     }
-    if (ch === "'") {
-      let str = "";
-      i++;
-      while (i < src.length) {
-        if (src[i] === "'" && src[i + 1] === "'") {
-          str += "'";
-          i += 2;
-        } else if (src[i] === "'") {
-          i++;
-          break;
-        } else {
-          str += src[i++];
-        }
+    return decisions;
+  }
+  if ("aggregates" in select) {
+    const decisions = [];
+    if (select.fields) {
+      for (const field of select.fields) {
+        decisions.push({ type: "select", column: field, table: rootTable });
       }
-      tokens.push({ kind: "STRING", value: str });
-      continue;
     }
-    if (/[a-zA-Z_]/.test(ch)) {
-      let ident = "";
-      while (i < src.length && /[a-zA-Z0-9_]/.test(src[i])) {
-        ident += src[i++];
+    for (const agg of select.aggregates) {
+      const aggDecision = {
+        type: "selectFunction",
+        function: agg.function === "count" && agg.field === "*" ? "count" : agg.function,
+        column: agg.field ?? "*",
+        table: rootTable
+      };
+      if (agg.as) {
+        aggDecision.alias = agg.as;
       }
-      tokens.push({ kind: "IDENT", value: ident });
-      continue;
-    }
-    if (ch === ":" && src[i + 1] === ":") {
-      tokens.push({ kind: "CAST", value: "::" });
-      i += 2;
-      continue;
-    }
-    if (["+", "-", "*", "/"].includes(ch)) {
-      tokens.push({ kind: "OP", value: ch });
-      i++;
-      continue;
-    }
-    if (ch === "(") {
-      tokens.push({ kind: "LPAREN", value: "(" });
-      i++;
-      continue;
-    }
-    if (ch === ")") {
-      tokens.push({ kind: "RPAREN", value: ")" });
-      i++;
-      continue;
-    }
-    if (ch === ",") {
-      tokens.push({ kind: "COMMA", value: "," });
-      i++;
-      continue;
-    }
-    if (ch === ".") {
-      tokens.push({ kind: "DOT", value: "." });
-      i++;
-      continue;
+      applyFilterCondition(aggDecision, agg.filter, rootTable);
+      decisions.push(aggDecision);
     }
-    throw new Error(
-      `parseExpression: unexpected character '${ch}' at position ${i} in: ${input}`
-    );
+    return decisions;
   }
-  tokens.push({ kind: "EOF", value: "" });
-  return tokens;
+  return [{ type: "select", column: "*", table: rootTable }];
 }
-function buildAExpr(op3, left, right) {
-  return {
-    A_Expr: {
-      kind: "AEXPR_OP",
-      name: [{ String: { sval: op3 } }],
-      lexpr: left,
-      rexpr: right
-    }
-  };
+function convertWhere(where, rootTable) {
+  const decision = convertWhereCondition(where, rootTable);
+  return decision ? [decision] : [];
 }
-function parseExpression(sqlFragment) {
-  const trimmed = sqlFragment.trim();
-  if (!trimmed) {
-    throw new Error("parseExpression: empty SQL fragment");
+function assertNoUnsupportedSubqueryModifiers(subquery, context) {
+  const unsupported = [];
+  if (subquery.groupBy && subquery.groupBy.length > 0)
+    unsupported.push("GROUP BY");
+  if (subquery.having) unsupported.push("HAVING");
+  if (subquery.offset != null) unsupported.push("OFFSET");
+  if (subquery.distinct) unsupported.push("DISTINCT");
+  if (subquery.distinctOn && subquery.distinctOn.length > 0)
+    unsupported.push("DISTINCT ON");
+  if (subquery.include && subquery.include.length > 0)
+    unsupported.push("include (relation hydration)");
+  if (subquery.joins && subquery.joins.length > 0) unsupported.push("joins");
+  if (subquery.existsWrap) unsupported.push("existsWrap");
+  if (subquery.lock) unsupported.push("lock");
+  if (subquery.batchValuesSource) unsupported.push("batchValuesSource");
+  if (context === "rawExists" || context === "scalar-direct") {
+    if (subquery.limit != null) unsupported.push("LIMIT");
   }
-  const tokens = tokenise(trimmed);
-  const parser = new Parser(tokens);
-  const node = parser.parseExpr();
-  if (parser["peek"]().kind !== "EOF") {
-    const remaining = tokens.slice(parser["pos"]).map((t) => t.value).join(" ");
-    throw new Error(
-      `parseExpression: unexpected trailing tokens '${remaining}' in: ${sqlFragment}`
+  if (context === "rawExists" || context === "scalar-direct") {
+    if (subquery.orderBy && subquery.orderBy.length > 0) {
+      unsupported.push("ORDER BY");
+    }
+  } else if (subquery.orderBy && subquery.orderBy.length > 0) {
+    const hasExpressionSort = subquery.orderBy.some(
+      (o) => !("field" in o) || o.field == null
     );
+    if (hasExpressionSort)
+      unsupported.push(
+        "orderBy with expression (only field-based ORDER BY is supported)"
+      );
   }
-  return node;
-}
-var Parser;
-var init_raw_expression_parser = __esm({
-  "src/raw-expression-parser.ts"() {
-    "use strict";
-    Parser = class {
-      constructor(tokens) {
-        this.tokens = tokens;
-      }
-      tokens;
-      pos = 0;
-      peek() {
-        return this.tokens[this.pos];
-      }
-      consume() {
-        const tok = this.tokens[this.pos];
-        this.pos++;
-        return tok;
-      }
+  if (context === "IN") {
+    const select = subquery.select;
+    if (!select) {
+      unsupported.push(
+        "missing select (IN subquery must project exactly one named column)"
+      );
+    } else if (select.type === "aggregate") {
+      unsupported.push(
+        "aggregate SELECT (use a scalar subquery comparison instead)"
+      );
+    } else if (select.type === "expressions") {
+      unsupported.push("expressions SELECT (not supported in IN subquery)");
+    } else if (select.type === "all") {
+      unsupported.push(
+        "SELECT * / all (IN subquery must project exactly one named column)"
+      );
+    } else if (select.type === "fields" || Array.isArray(select.fields) || // Also catch the typeless `{ fields: undefined | null }` shape: the
+    // `fields` key is present (triggering isSelectWithFields in the compiler)
+    // but the value is not a non-empty array.  Without this branch,
+    // `{ fields: undefined }` falls through all checks and the compiler
+    // silently falls back to SELECT *, producing wrong SQL.
+    // Guard: `in` operator crashes on primitives; a string select like 'id'
+    // is a valid single-column selector — only check for the `fields` key on
+    // actual objects.
+    typeof select === "object" && select !== null && "fields" in select) {
+      if (!select.fields || select.fields.length === 0) {
+        unsupported.push(
+          "empty fields list (IN subquery must project exactly one named column)"
+        );
+      } else if (select.fields.length > 1) {
+        unsupported.push(
+          `multi-field projection [${select.fields.join(", ")}] (IN subquery must project exactly one named column \u2014 use a single field)`
+        );
+      } else if (typeof select.fields[0] !== "string") {
+        unsupported.push(
+          `non-string field element ${JSON.stringify(select.fields[0])} (IN subquery fields must contain a plain column name string)`
+        );
+      }
+    }
+  }
+  const isScalarContext = context === "scalar" || context === "scalar-direct";
+  if (isScalarContext) {
+    const select = subquery.select;
+    if (select?.type === "expressions") {
+      unsupported.push("expressions SELECT (not supported in scalar subquery)");
+    } else if (select?.type === "fields" && select.fields != null && select.fields.length > 1) {
+      unsupported.push(
+        `multi-field projection [${select.fields.join(", ")}] (scalar subquery must project exactly one column \u2014 use a single field)`
+      );
+    } else if (select?.type === "aggregate" && select.aggregates != null && select.aggregates.length > 1) {
+      unsupported.push(
+        `multi-aggregate projection (scalar subquery must project exactly one column \u2014 use a single aggregate)`
+      );
+    }
+  }
+  if (unsupported.length > 0) {
+    const label = context === "IN" ? "IN" : context === "rawExists" ? "rawExists" : "scalar";
+    throw new Error(
+      `${label} subquery with ${unsupported.join(", ")} is not supported \u2014 it would silently change which rows match; restructure the query or use a CTE.`
+    );
+  }
+}
+function isOuterRef(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v.kind === "ref" && v.outer === true;
+}
+function containsOuterRef(where) {
+  if (!where || typeof where !== "object") return false;
+  const w = where;
+  if (isOuterRef(w)) return true;
+  for (const value of Object.values(w)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (containsOuterRef(item)) return true;
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (containsOuterRef(value)) return true;
+    }
+  }
+  return false;
+}
+function convertComparison(cond, rootTable) {
+  const rawValue = cond.value;
+  const resolvedValue = isOuterRef(rawValue) ? {
+    kind: "fieldRef",
+    scope: "outer",
+    column: rawValue.column
+  } : rawValue;
+  const result = {
+    type: "where",
+    column: cond.field,
+    operator: cond.operator,
+    value: resolvedValue,
+    table: rootTable
+  };
+  if (cond.jsonPath) result.jsonPath = cond.jsonPath;
+  if (cond.jsonMode) result.jsonMode = cond.jsonMode;
+  return result;
+}
+function convertLike(cond, rootTable) {
+  const result = {
+    type: "where",
+    column: cond.field,
+    operator: cond.caseInsensitive ? "ilike" : "like",
+    value: cond.pattern,
+    table: rootTable
+  };
+  if (cond.escape !== void 0) result.escape = cond.escape;
+  return result;
+}
+function convertIn(cond, rootTable) {
+  const rawSubquery = cond.subquery;
+  if (rawSubquery) {
+    assertNoUnsupportedSubqueryModifiers(rawSubquery, "IN");
+    const selectField = rawSubquery.select;
+    const selectColumn = selectField && "fields" in selectField && Array.isArray(selectField.fields) ? selectField.fields[0] ?? "*" : "*";
+    const subConditions = rawSubquery.where ? (() => {
+      const converted = convertWhereCondition(
+        rawSubquery.where,
+        rawSubquery.from
+      );
+      return converted ? [converted] : [];
+    })() : [];
+    const rawLimit = rawSubquery.limit;
+    const rawOrderBy = rawSubquery.orderBy;
+    return {
+      type: "where",
+      column: cond.field,
+      operator: cond.not ? "notInSubquery" : "inSubquery",
+      targetTable: rawSubquery.from,
+      selectColumn,
+      conditions: subConditions,
+      table: rootTable,
+      // Provenance: original QueryIntent for validation in buildPredicateSubquerySelect
+      subqueryIntent: rawSubquery,
+      ...rawLimit != null && { limit: rawLimit },
+      ...rawOrderBy && {
+        orderBy: rawOrderBy.map((o) => ({
+          field: o.field,
+          direction: o.direction?.toLowerCase() ?? "asc"
+        }))
+      }
+    };
+  }
+  return {
+    type: "where",
+    column: cond.field,
+    operator: cond.not ? "notIn" : "in",
+    value: cond.values,
+    table: rootTable
+  };
+}
+function convertNull(cond, rootTable) {
+  return {
+    type: "where",
+    column: cond.field,
+    operator: cond.operator,
+    table: rootTable
+  };
+}
+function convertRange(cond, rootTable) {
+  const rangeOperator = cond.operator;
+  const col = cond.field;
+  if (rangeOperator === "contains" || rangeOperator === "containedBy" || rangeOperator === "overlaps") {
+    return {
+      type: "where",
+      column: col,
+      operator: rangeOperator,
+      value: cond.value,
+      table: rootTable
+    };
+  }
+  if (rangeOperator === "between") {
+    const rangeVal = cond.value;
+    return {
+      type: "where",
+      column: col,
+      operator: "between",
+      value: [rangeVal.lower, rangeVal.upper],
+      table: rootTable
+    };
+  }
+  if (cond.gte !== void 0 && cond.lte !== void 0) {
+    return {
+      type: "where",
+      column: col,
+      operator: "between",
+      value: [cond.gte, cond.lte],
+      table: rootTable
+    };
+  }
+  if (cond.gte !== void 0) {
+    return {
+      type: "where",
+      column: col,
+      operator: "gte",
+      value: cond.gte,
+      table: rootTable
+    };
+  }
+  if (cond.gt !== void 0) {
+    return {
+      type: "where",
+      column: col,
+      operator: "gt",
+      value: cond.gt,
+      table: rootTable
+    };
+  }
+  if (cond.lte !== void 0) {
+    return {
+      type: "where",
+      column: col,
+      operator: "lte",
+      value: cond.lte,
+      table: rootTable
+    };
+  }
+  if (cond.lt !== void 0) {
+    return {
+      type: "where",
+      column: col,
+      operator: "lt",
+      value: cond.lt,
+      table: rootTable
+    };
+  }
+  return null;
+}
+function convertLogicalGroup(cond, rootTable, decisionType) {
+  const subDecisions = [];
+  for (const sub of cond.conditions) {
+    const subDecision = convertWhereCondition(sub, rootTable);
+    if (subDecision) subDecisions.push(subDecision);
+  }
+  if (subDecisions.length === 0) return null;
+  return { type: decisionType, conditions: subDecisions };
+}
+function convertNot(cond, rootTable) {
+  const subDecision = convertWhereCondition(
+    cond.condition,
+    rootTable
+  );
+  if (!subDecision) return null;
+  return { type: "whereNot", conditions: [subDecision] };
+}
+function convertExistsLike(cond, operator) {
+  const targetTable = cond.relation;
+  const subDecisions = cond.where ? convertWhere(cond.where, targetTable) : [];
+  const base = { type: "where", operator, targetTable };
+  return subDecisions.length > 0 ? { ...base, conditions: subDecisions } : base;
+}
+function convertSubquery(cond) {
+  const field = cond.field;
+  const operator = cond.operator;
+  const subquery = cond.subquery;
+  if (!subquery || !field) return null;
+  assertNoUnsupportedSubqueryModifiers(subquery, "scalar");
+  if (subquery.where && containsOuterRef(subquery.where)) {
+    throw new Error(
+      'scalar subquery with correlated outerRef() is not yet supported \u2014 use exists("relation", { where: ... }) when a schema relation exists, or restructure the query to avoid the correlation.'
+    );
+  }
+  const targetTable = subquery.from;
+  let selectColumn = "*";
+  let aggregate;
+  const select = subquery.select;
+  if (select) {
+    if ("type" in select && select.type === "aggregate") {
+      const agg = select.aggregates?.[0];
+      if (agg) {
+        aggregate = agg.function;
+        selectColumn = agg.field ?? "*";
+      }
+    } else if ("fields" in select && select.fields?.length) {
+      selectColumn = select.fields[0];
+    }
+  }
+  const subConditions = [];
+  if (subquery.where) {
+    const innerWhere = convertWhereCondition(
+      subquery.where,
+      targetTable
+    );
+    if (innerWhere) subConditions.push(innerWhere);
+  }
+  const rawLimit = subquery.limit;
+  const rawOrderBy = subquery.orderBy;
+  const opMap = {
+    eq: "=",
+    neq: "!=",
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<="
+  };
+  return {
+    type: "where",
+    column: field,
+    operator: "scalarSubquery",
+    targetTable,
+    selectColumn,
+    subqueryOperator: opMap[operator] ?? "=",
+    // Provenance: original QueryIntent for validation in buildPredicateSubquerySelect
+    subqueryIntent: subquery,
+    ...aggregate && { aggregate },
+    ...subConditions.length > 0 && { conditions: subConditions },
+    ...rawLimit != null && { limit: rawLimit },
+    ...rawOrderBy && rawOrderBy.length > 0 && {
+      orderBy: rawOrderBy.map((o) => ({
+        field: o.field,
+        direction: o.direction?.toLowerCase() ?? "asc"
+      }))
+    }
+  };
+}
+function convertWhereCondition(condition, rootTable) {
+  const cond = condition;
+  switch (cond.kind) {
+    case "comparison":
+      return convertComparison(cond, rootTable);
+    case "like":
+      return convertLike(cond, rootTable);
+    case "in":
+      return convertIn(cond, rootTable);
+    case "null":
+      return convertNull(cond, rootTable);
+    case "range":
+      return convertRange(cond, rootTable);
+    case "and":
+      return convertLogicalGroup(cond, rootTable, "whereAnd");
+    case "or":
+      return convertLogicalGroup(cond, rootTable, "whereOr");
+    case "not":
+      return convertNot(cond, rootTable);
+    case "exists":
+      return convertExistsLike(cond, "exists");
+    case "notExists":
+      return convertExistsLike(cond, "notExists");
+    case "relationFilter": {
+      const mode = cond.mode || "some";
+      const operator = mode === "none" ? "notExists" : mode === "every" ? "every" : "exists";
+      return convertExistsLike(cond, operator);
+    }
+    case "subquery":
+      return convertSubquery(cond);
+    case "rawExists":
+    case "rawNotExists": {
+      const sub = cond.subquery;
+      if (!sub) {
+        throw new Error(
+          `${cond.kind}: missing subquery \u2014 pass the result of subquery(table).select(...) or a builder with buildIntent()`
+        );
+      }
+      assertNoUnsupportedSubqueryModifiers(sub, "rawExists");
+      if (sub.where && containsOuterRef(sub.where)) {
+        throw new Error(
+          `${cond.kind}: correlated subqueries (outerRef inside the inner WHERE) are not yet supported. Workaround: use exists("relation", { where: ... }) when a schema relation exists, or wait for the rawExists correlation pipeline (tracked in TODO).`
+        );
+      }
+      return {
+        type: "where",
+        operator: cond.kind,
+        // Reuse expressionIntent (already present on PlanDecision) to carry the
+        // inner QueryIntent; the rawExistsHandler discriminates by operator name.
+        expressionIntent: sub,
+        table: rootTable
+      };
+    }
+    case "jsonContains":
+      return {
+        type: "where",
+        column: cond.field,
+        operator: cond.reversed ? "jsonContainedBy" : "jsonContains",
+        value: cond.value,
+        table: rootTable
+      };
+    case "any":
+      return {
+        type: "where",
+        column: cond.field,
+        operator: "any",
+        values: cond.values,
+        table: rootTable
+      };
+    case "jsonExists":
+      return {
+        type: "where",
+        column: cond.field,
+        operator: "jsonExists",
+        value: cond.key,
+        table: rootTable
+      };
+    case "expression":
+      return {
+        type: "where",
+        operator: "expression",
+        expressionIntent: cond.expr,
+        value: cond.value,
+        subqueryOperator: cond.operator,
+        table: rootTable
+      };
+    default:
+      return null;
+  }
+}
+function convertOrderBy(order, rootTable) {
+  const direction = order.direction === "desc" ? "DESC" : "ASC";
+  const nulls = order.nulls ? order.nulls === "first" ? "FIRST" : "LAST" : void 0;
+  if (order.expression) {
+    const base = {
+      type: "orderBy",
+      expressionIntent: order.expression,
+      direction,
+      table: rootTable
+    };
+    if (nulls) {
+      return { ...base, nulls };
+    }
+    return base;
+  }
+  const decision = {
+    type: "orderBy",
+    direction,
+    table: rootTable,
+    // field is optional in OrderByIntent after expression extension (exactOptionalPropertyTypes)
+    ...order.field ? { column: order.field } : {}
+  };
+  if (nulls) {
+    return { ...decision, nulls };
+  }
+  return decision;
+}
+var init_intent_to_decisions = __esm({
+  "src/intent-to-decisions.ts"() {
+    "use strict";
+    init_select_expression_handlers();
+  }
+});
+
+// src/handlers/types.ts
+function createCompilerState() {
+  return {
+    parameters: [],
+    paramIndex: 0,
+    ctes: /* @__PURE__ */ new Map(),
+    aliases: /* @__PURE__ */ new Map(),
+    joins: []
+  };
+}
+function isSqlExpression(value) {
+  return typeof value === "object" && value !== null && "sql" in value && typeof value.sql === "string";
+}
+function isRangeValue(value) {
+  return typeof value === "object" && value !== null && ("lower" in value || "upper" in value);
+}
+function isParamRef(value) {
+  return typeof value === "object" && value !== null && "paramIndex" in value && typeof value.paramIndex === "number";
+}
+function isSelectWithFields(value) {
+  return typeof value === "object" && value !== null && "fields" in value && (Array.isArray(value.fields) || value.fields === void 0);
+}
+var COMPARISON_OPERATORS, PATTERN_OPERATORS, NULL_OPERATORS, COLLECTION_OPERATORS, LOGICAL_OPERATORS, ALL_OPERATORS;
+var init_types = __esm({
+  "src/handlers/types.ts"() {
+    "use strict";
+    COMPARISON_OPERATORS = {
+      EQ: "=",
+      NEQ: "!=",
+      LT: "<",
+      LTE: "<=",
+      GT: ">",
+      GTE: ">=",
+      // Aliases
+      eq: "=",
+      ne: "!=",
+      lt: "<",
+      lte: "<=",
+      gt: ">",
+      gte: ">="
+    };
+    PATTERN_OPERATORS = {
+      LIKE: "like",
+      ILIKE: "ilike",
+      NOT_LIKE: "notLike",
+      NOT_ILIKE: "notIlike"
+    };
+    NULL_OPERATORS = {
+      IS_NULL: "isNull",
+      IS_NOT_NULL: "isNotNull"
+    };
+    COLLECTION_OPERATORS = {
+      IN: "in",
+      NOT_IN: "notIn",
+      ANY: "any"
+    };
+    LOGICAL_OPERATORS = {
+      AND: "and",
+      OR: "or",
+      NOT: "not"
+    };
+    ALL_OPERATORS = {
+      ...COMPARISON_OPERATORS,
+      ...PATTERN_OPERATORS,
+      ...NULL_OPERATORS,
+      ...COLLECTION_OPERATORS,
+      ...LOGICAL_OPERATORS
+    };
+  }
+});
+
+// src/raw-expression-parser.ts
+function tokenise(input) {
+  const tokens = [];
+  let i = 0;
+  const src = input.trim();
+  while (i < src.length) {
+    const ch = src[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(ch)) {
+      let num = "";
+      while (i < src.length && /[0-9]/.test(src[i])) {
+        num += src[i++];
+      }
+      if (src[i] === "." && i + 1 < src.length && /[0-9]/.test(src[i + 1])) {
+        num += src[i++];
+        while (i < src.length && /[0-9]/.test(src[i])) {
+          num += src[i++];
+        }
+        tokens.push({ kind: "FLOAT", value: num });
+      } else {
+        tokens.push({ kind: "INT", value: num });
+      }
+      continue;
+    }
+    if (ch === "'") {
+      let str = "";
+      i++;
+      while (i < src.length) {
+        if (src[i] === "'" && src[i + 1] === "'") {
+          str += "'";
+          i += 2;
+        } else if (src[i] === "'") {
+          i++;
+          break;
+        } else {
+          str += src[i++];
+        }
+      }
+      tokens.push({ kind: "STRING", value: str });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(ch)) {
+      let ident = "";
+      while (i < src.length && /[a-zA-Z0-9_]/.test(src[i])) {
+        ident += src[i++];
+      }
+      tokens.push({ kind: "IDENT", value: ident });
+      continue;
+    }
+    if (ch === ":" && src[i + 1] === ":") {
+      tokens.push({ kind: "CAST", value: "::" });
+      i += 2;
+      continue;
+    }
+    if (["+", "-", "*", "/"].includes(ch)) {
+      tokens.push({ kind: "OP", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ kind: "LPAREN", value: "(" });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ kind: "RPAREN", value: ")" });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ kind: "COMMA", value: "," });
+      i++;
+      continue;
+    }
+    if (ch === ".") {
+      tokens.push({ kind: "DOT", value: "." });
+      i++;
+      continue;
+    }
+    throw new Error(
+      `parseExpression: unexpected character '${ch}' at position ${i} in: ${input}`
+    );
+  }
+  tokens.push({ kind: "EOF", value: "" });
+  return tokens;
+}
+function buildAExpr(op3, left, right) {
+  return {
+    A_Expr: {
+      kind: "AEXPR_OP",
+      name: [{ String: { sval: op3 } }],
+      lexpr: left,
+      rexpr: right
+    }
+  };
+}
+function parseExpression(sqlFragment) {
+  const trimmed = sqlFragment.trim();
+  if (!trimmed) {
+    throw new Error("parseExpression: empty SQL fragment");
+  }
+  const tokens = tokenise(trimmed);
+  const parser = new Parser(tokens);
+  const node = parser.parseExpr();
+  if (parser["peek"]().kind !== "EOF") {
+    const remaining = tokens.slice(parser["pos"]).map((t) => t.value).join(" ");
+    throw new Error(
+      `parseExpression: unexpected trailing tokens '${remaining}' in: ${sqlFragment}`
+    );
+  }
+  return node;
+}
+var Parser;
+var init_raw_expression_parser = __esm({
+  "src/raw-expression-parser.ts"() {
+    "use strict";
+    Parser = class {
+      constructor(tokens) {
+        this.tokens = tokens;
+      }
+      tokens;
+      pos = 0;
+      peek() {
+        return this.tokens[this.pos];
+      }
+      consume() {
+        const tok = this.tokens[this.pos];
+        this.pos++;
+        return tok;
+      }
       expect(kind) {
         const tok = this.peek();
         if (tok.kind !== kind) {
@@ -2121,566 +2576,177 @@ var init_raw_expression_parser = __esm({
           int4: "int4",
           int2: "int2",
           smallint: "int2",
-          int8: "int8",
-          bigint: "int8",
-          float4: "float4",
-          real: "float4",
-          float8: "float8",
-          "double precision": "float8",
-          bool: "bool",
-          boolean: "bool",
-          text: "text",
-          varchar: "varchar",
-          bpchar: "bpchar",
-          char: "bpchar",
-          bytea: "bytea",
-          date: "date",
-          time: "time",
-          timetz: "timetz",
-          timestamp: "timestamp",
-          timestamptz: "timestamptz",
-          interval: "interval",
-          numeric: "numeric",
-          decimal: "numeric",
-          uuid: "uuid",
-          json: "json",
-          jsonb: "jsonb",
-          oid: "oid",
-          name: "name"
-        };
-        const pgName = pgCatalogTypes[lower];
-        if (pgName) {
-          return {
-            names: [
-              { String: { sval: "pg_catalog" } },
-              { String: { sval: pgName } }
-            ],
-            typemod: -1
-          };
-        }
-        return {
-          names: [{ String: { sval: lower } }],
-          typemod: -1
-        };
-      }
-    };
-  }
-});
-
-// src/compiler-utils.ts
-import { InvalidOperationError } from "@dbsp/core";
-function inferPgArrayType(columnName, columnTypes, sampleValue) {
-  if (columnTypes?.[columnName]) {
-    const pgBase = mapToPgBaseType(columnTypes[columnName]);
-    return `${pgBase}[]`;
-  }
-  if (sampleValue !== null && sampleValue !== void 0) {
-    if (typeof sampleValue === "bigint") return "int8[]";
-    if (typeof sampleValue === "number") {
-      return Number.isInteger(sampleValue) ? "int4[]" : "float8[]";
-    }
-    if (typeof sampleValue === "string") return "text[]";
-    if (typeof sampleValue === "boolean") return "bool[]";
-    if (typeof sampleValue === "object") return "jsonb[]";
-  }
-  return "text[]";
-}
-function mapToPgBaseType(pgType) {
-  const normalized = pgType.toUpperCase().replace(/\(.*\)/, "").trim();
-  switch (normalized) {
-    // ColumnType aliases (lowercase ColumnType values from ModelIR)
-    case "STRING":
-      return "text";
-    case "NUMBER":
-      return "float8";
-    case "DATETIME":
-      return "timestamptz";
-    case "TIME":
-      return "time";
-    // PostgreSQL native types
-    case "INTEGER":
-    case "INT":
-    case "INT4":
-    case "SERIAL":
-      return "int4";
-    case "BIGINT":
-    case "INT8":
-    case "BIGSERIAL":
-      return "int8";
-    case "SMALLINT":
-    case "INT2":
-      return "int2";
-    case "REAL":
-    case "FLOAT4":
-      return "float4";
-    case "DOUBLE PRECISION":
-    case "FLOAT8":
-    case "FLOAT":
-    case "NUMERIC":
-    case "DECIMAL":
-      return "float8";
-    case "TEXT":
-    case "VARCHAR":
-    case "CHAR":
-    case "CHARACTER VARYING":
-      return "text";
-    case "BOOLEAN":
-    case "BOOL":
-      return "bool";
-    case "JSON":
-    case "JSONB":
-      return "jsonb";
-    case "UUID":
-      return "uuid";
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIMESTAMP WITH TIME ZONE":
-      return "timestamptz";
-    case "DATE":
-      return "date";
-    default:
-      return pgType.toLowerCase();
-  }
-}
-function stripArraySuffix(pgArrayType) {
-  return pgArrayType.endsWith("[]") ? pgArrayType.slice(0, -2) : pgArrayType;
-}
-function mapModelIRTypeToPgBase(dataType) {
-  const t = dataType.toLowerCase();
-  if (t === "integer" || t === "int" || t === "serial" || t === "bigserial")
-    return "int4";
-  if (t === "bigint") return "int8";
-  if (t === "decimal" || t === "float" || t === "double" || t === "real" || t === "numeric")
-    return "float8";
-  if (t === "text" || t === "string" || t === "varchar" || t === "char")
-    return "text";
-  if (t === "boolean" || t === "bool") return "bool";
-  if (t === "json" || t === "jsonb") return "jsonb";
-  if (t === "uuid") return "uuid";
-  if (t === "timestamp" || t === "timestamptz" || t === "datetime")
-    return "timestamptz";
-  if (t === "date") return "date";
-  return void 0;
-}
-function transposeToColumnArrays(columns, values) {
-  return columns.map((_, colIdx) => values.map((row) => row[colIdx]));
-}
-function validateBatchCardinality(columns, values) {
-  for (let i = 0; i < values.length; i++) {
-    const row = values[i];
-    if (row === void 0 || row.length !== columns.length) {
-      throw new InvalidOperationError(
-        "insert",
-        `Array length mismatch at row ${i}: expected ${columns.length} columns, got ${row?.length ?? 0}`
-      );
-    }
-  }
-}
-function parseRawExpression(sqlFragment) {
-  try {
-    return parseExpression(sqlFragment);
-  } catch {
-    throw new Error(
-      `sql(): cannot parse raw SQL fragment as expression: ${sqlFragment}`
-    );
-  }
-}
-var init_compiler_utils = __esm({
-  "src/compiler-utils.ts"() {
-    "use strict";
-    init_raw_expression_parser();
-  }
-});
-
-// src/validate.ts
-function validateIdentifier(value, type) {
-  if (!value || value.length === 0) {
-    throw new InvalidIdentifierError(value, type, "cannot be empty");
-  }
-  if (value.length > 63) {
-    throw new InvalidIdentifierError(
-      value,
-      type,
-      `exceeds maximum length of 63 characters (got ${value.length})`
-    );
-  }
-  const validIdentifierPattern = /^[a-zA-Z_][a-zA-Z0-9_$]*$/;
-  if (!validIdentifierPattern.test(value)) {
-    if (/[\x00-\x1f\x7f]/.test(value)) {
-      throw new InvalidIdentifierError(
-        value,
-        type,
-        "contains control characters"
-      );
-    }
-    if (/^[0-9]/.test(value)) {
-      throw new InvalidIdentifierError(
-        value,
-        type,
-        "cannot start with a digit"
-      );
-    }
-    if (/[^\w$]/.test(value)) {
-      throw new InvalidIdentifierError(
-        value,
-        type,
-        "contains invalid characters (only letters, digits, underscore, and $ allowed)"
-      );
-    }
-    throw new InvalidIdentifierError(
-      value,
-      type,
-      "does not match valid identifier pattern"
-    );
-  }
-  if (value.includes("\0")) {
-    throw new InvalidIdentifierError(value, type, "contains null byte");
-  }
-}
-function isReservedKeyword(value) {
-  return SQL_RESERVED_KEYWORDS.has(value.toLowerCase());
-}
-function validateQualifiedIdentifier(schemaTable) {
-  const parts = schemaTable.split(".");
-  if (parts.length === 1) {
-    validateIdentifier(parts[0], "table");
-    return { table: parts[0] };
+          int8: "int8",
+          bigint: "int8",
+          float4: "float4",
+          real: "float4",
+          float8: "float8",
+          "double precision": "float8",
+          bool: "bool",
+          boolean: "bool",
+          text: "text",
+          varchar: "varchar",
+          bpchar: "bpchar",
+          char: "bpchar",
+          bytea: "bytea",
+          date: "date",
+          time: "time",
+          timetz: "timetz",
+          timestamp: "timestamp",
+          timestamptz: "timestamptz",
+          interval: "interval",
+          numeric: "numeric",
+          decimal: "numeric",
+          uuid: "uuid",
+          json: "json",
+          jsonb: "jsonb",
+          oid: "oid",
+          name: "name"
+        };
+        const pgName = pgCatalogTypes[lower];
+        if (pgName) {
+          return {
+            names: [
+              { String: { sval: "pg_catalog" } },
+              { String: { sval: pgName } }
+            ],
+            typemod: -1
+          };
+        }
+        return {
+          names: [{ String: { sval: lower } }],
+          typemod: -1
+        };
+      }
+    };
   }
-  if (parts.length === 2) {
-    const schema = parts[0];
-    const table = parts[1];
-    validateIdentifier(schema, "schema");
-    validateIdentifier(table, "table");
-    return { schema, table };
+});
+
+// src/compiler-utils.ts
+import { InvalidOperationError, validateTypeName as validateTypeName2 } from "@dbsp/core";
+function inferPgArrayType(columnName, columnTypes, sampleValue) {
+  if (columnTypes?.[columnName]) {
+    const pgBase = mapToPgBaseType(columnTypes[columnName]);
+    return `${pgBase}[]`;
   }
-  throw new InvalidIdentifierError(
-    schemaTable,
-    "table",
-    "too many dots in qualified name (expected schema.table or table)"
-  );
-}
-function validateIdentifiers(identifiers) {
-  for (const [value, type] of Object.entries(identifiers)) {
-    if (value) {
-      validateIdentifier(value, type);
+  if (sampleValue !== null && sampleValue !== void 0) {
+    if (typeof sampleValue === "bigint") return "int8[]";
+    if (typeof sampleValue === "number") {
+      return Number.isInteger(sampleValue) ? "int4[]" : "float8[]";
     }
+    if (typeof sampleValue === "string") return "text[]";
+    if (typeof sampleValue === "boolean") return "bool[]";
+    if (typeof sampleValue === "object") return "jsonb[]";
   }
+  return "text[]";
 }
-function sanitizeForDisplay(value) {
-  return value.replace(/[\x00-\x1f\x7f]/g, "?").slice(0, 100);
-}
-function validateExtensionName(name, context = "extension") {
-  if (!name || name.length === 0) {
-    throw new InvalidIdentifierError(name, context, "cannot be empty");
-  }
-  if (name.length > 63) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      `exceeds maximum length of 63 characters (got ${name.length})`
-    );
-  }
-  if (/[\x00-\x1f\x7f]/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains control characters"
-    );
-  }
-  if (/[\\]/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains backslash (forbidden in extension names)"
-    );
-  }
-  if (/"/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains double-quote (identifier injection risk)"
-    );
-  }
-  if (/'/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains single-quote (string injection risk)"
-    );
-  }
-  if (/;/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains semicolon (statement injection risk)"
-    );
-  }
-  if (/--/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains line-comment marker (--)"
-    );
-  }
-  if (/\/\*/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains block-comment opener (/*)"
-    );
-  }
-  if (/\*\//.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains block-comment closer (*/)"
-    );
-  }
-  if (/\$\$/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains dollar-quoting ($$)"
-    );
-  }
-  if (/\s/.test(name)) {
-    throw new InvalidIdentifierError(name, context, "contains whitespace");
-  }
-  if (!/^[a-zA-Z0-9_\-.]+$/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains characters not allowed in extension names (only letters, digits, underscore, hyphen, and dot allowed)"
-    );
-  }
-}
-function validateCollationName(name, context = "collation") {
-  if (!name || name.length === 0) {
-    throw new InvalidIdentifierError(name, context, "cannot be empty");
-  }
-  if (Buffer.byteLength(name, "utf8") > 63) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      `exceeds maximum length of 63 bytes (got ${Buffer.byteLength(name, "utf8")})`
-    );
-  }
-  if (/\x00/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains NUL byte (\\x00) which would be silently truncated by PostgreSQL"
-    );
-  }
-  if (/[\x01-\x1f\x7f]/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains control characters (only printable characters allowed)"
-    );
-  }
-  if (/[\\]/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains backslash (forbidden in collation names)"
-    );
-  }
-  if (/"/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains double-quote (identifier injection risk)"
-    );
-  }
-  if (/'/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains single-quote (string injection risk)"
-    );
-  }
-  if (/;/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains semicolon (statement injection risk)"
-    );
-  }
-  if (/--/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains line-comment marker (--)"
-    );
-  }
-  if (/\/\*/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains block-comment opener (/*)"
-    );
-  }
-  if (/\*\//.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains block-comment closer (*/)"
-    );
-  }
-  if (/\$\$/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains dollar-quoting ($$)"
-    );
-  }
-  if (/\s/.test(name)) {
-    throw new InvalidIdentifierError(name, context, "contains whitespace");
-  }
-  if (!/^[a-zA-Z_][a-zA-Z0-9_.-]*(?:@[A-Za-z0-9-]{1,10})?$/.test(name)) {
-    throw new InvalidIdentifierError(
-      name,
-      context,
-      "contains characters not allowed in collation names (only letters, digits, underscore, hyphen, and dot allowed; optional @modifier must be 1-10 alphanumeric/hyphen characters, e.g. @euro, @latin9, @iso8859-15)"
-    );
+function mapToPgBaseType(pgType) {
+  const normalized = pgType.toUpperCase().replace(/\(.*\)/, "").trim();
+  switch (normalized) {
+    // ColumnType aliases (lowercase ColumnType values from ModelIR)
+    case "STRING":
+      return "text";
+    case "NUMBER":
+      return "float8";
+    case "DATETIME":
+      return "timestamptz";
+    case "TIME":
+      return "time";
+    // PostgreSQL native types
+    case "INTEGER":
+    case "INT":
+    case "INT4":
+    case "SERIAL":
+      return "int4";
+    case "BIGINT":
+    case "INT8":
+    case "BIGSERIAL":
+      return "int8";
+    case "SMALLINT":
+    case "INT2":
+      return "int2";
+    case "REAL":
+    case "FLOAT4":
+      return "float4";
+    case "DOUBLE PRECISION":
+    case "FLOAT8":
+    case "FLOAT":
+    case "NUMERIC":
+    case "DECIMAL":
+      return "float8";
+    case "TEXT":
+    case "VARCHAR":
+    case "CHAR":
+    case "CHARACTER VARYING":
+      return "text";
+    case "BOOLEAN":
+    case "BOOL":
+      return "bool";
+    case "JSON":
+    case "JSONB":
+      return "jsonb";
+    case "UUID":
+      return "uuid";
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+      return "timestamptz";
+    case "DATE":
+      return "date";
+    default: {
+      const customType = pgType.toLowerCase();
+      validateTypeName2(customType);
+      return customType;
+    }
   }
 }
-function validateSqlExpression(sql, context) {
-  if (/[;]|--|\/\*|\*\/|\$\$|\\/.test(sql)) {
-    throw new Error(
-      `Unsafe SQL expression in ${context}: contains forbidden characters (;, --, /*, */, "$$" (dollar-quoted strings), \\). Value: "${sql}"`
-    );
+function stripArraySuffix(pgArrayType) {
+  return pgArrayType.endsWith("[]") ? pgArrayType.slice(0, -2) : pgArrayType;
+}
+function mapModelIRTypeToPgBase(dataType) {
+  const t = dataType.toLowerCase();
+  if (t === "integer" || t === "int" || t === "serial" || t === "bigserial")
+    return "int4";
+  if (t === "bigint") return "int8";
+  if (t === "decimal" || t === "float" || t === "double" || t === "real" || t === "numeric")
+    return "float8";
+  if (t === "text" || t === "string" || t === "varchar" || t === "char")
+    return "text";
+  if (t === "boolean" || t === "bool") return "bool";
+  if (t === "json" || t === "jsonb") return "jsonb";
+  if (t === "uuid") return "uuid";
+  if (t === "timestamp" || t === "timestamptz" || t === "datetime")
+    return "timestamptz";
+  if (t === "date") return "date";
+  return void 0;
+}
+function transposeToColumnArrays(columns, values) {
+  return columns.map((_, colIdx) => values.map((row) => row[colIdx]));
+}
+function validateBatchCardinality(columns, values) {
+  for (let i = 0; i < values.length; i++) {
+    const row = values[i];
+    if (row === void 0 || row.length !== columns.length) {
+      throw new InvalidOperationError(
+        "insert",
+        `Array length mismatch at row ${i}: expected ${columns.length} columns, got ${row?.length ?? 0}`
+      );
+    }
   }
 }
-function validateDbTypeName(type) {
-  if (!SAFE_TYPE_PATTERN.test(type)) {
+function parseRawExpression(sqlFragment) {
+  try {
+    return parseExpression(sqlFragment);
+  } catch {
     throw new Error(
-      `Unsafe database type name: "${type}". Must match PostgreSQL type name rules.`
+      `sql(): cannot parse raw SQL fragment as expression: ${sqlFragment}`
     );
   }
-  return type;
 }
-var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_TYPE_PATTERN;
-var init_validate = __esm({
-  "src/validate.ts"() {
+var init_compiler_utils = __esm({
+  "src/compiler-utils.ts"() {
     "use strict";
-    SQL_RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
-      "all",
-      "analyse",
-      "analyze",
-      "and",
-      "any",
-      "array",
-      "as",
-      "asc",
-      "asymmetric",
-      "authorization",
-      "binary",
-      "both",
-      "case",
-      "cast",
-      "check",
-      "collate",
-      "collation",
-      "column",
-      "concurrently",
-      "constraint",
-      "create",
-      "cross",
-      "current_catalog",
-      "current_date",
-      "current_role",
-      "current_schema",
-      "current_time",
-      "current_timestamp",
-      "current_user",
-      "default",
-      "deferrable",
-      "desc",
-      "distinct",
-      "do",
-      "else",
-      "end",
-      "except",
-      "false",
-      "fetch",
-      "for",
-      "foreign",
-      "freeze",
-      "from",
-      "full",
-      "grant",
-      "group",
-      "having",
-      "ilike",
-      "in",
-      "initially",
-      "inner",
-      "intersect",
-      "into",
-      "is",
-      "isnull",
-      "join",
-      "lateral",
-      "leading",
-      "left",
-      "like",
-      "limit",
-      "localtime",
-      "localtimestamp",
-      "natural",
-      "not",
-      "notnull",
-      "null",
-      "offset",
-      "on",
-      "only",
-      "or",
-      "order",
-      "outer",
-      "overlaps",
-      "placing",
-      "primary",
-      "references",
-      "returning",
-      "right",
-      "select",
-      "session_user",
-      "similar",
-      "some",
-      "symmetric",
-      "table",
-      "timestamp",
-      "tablesample",
-      "then",
-      "to",
-      "trailing",
-      "true",
-      "union",
-      "unique",
-      "user",
-      "using",
-      "variadic",
-      "verbose",
-      "when",
-      "where",
-      "window",
-      "with"
-    ]);
-    InvalidIdentifierError = class extends Error {
-      constructor(identifier, identifierType, reason) {
-        super(`Invalid ${identifierType} identifier "${identifier}": ${reason}`);
-        this.identifier = identifier;
-        this.identifierType = identifierType;
-        this.reason = reason;
-        this.name = "InvalidIdentifierError";
-      }
-      identifier;
-      identifierType;
-      reason;
-    };
-    SAFE_TYPE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])?$/;
+    init_raw_expression_parser();
   }
 });
 
@@ -9516,14 +9582,50 @@ function idxName(table, columns, customName) {
 function buildPolicySQL(tableName, policy, schemaName) {
   const policyName = quoteIdent2(policy.name, "alias");
   const qt = qualifyTable(tableName, schemaName);
-  const forClause = policy.command && policy.command !== "ALL" ? ` FOR ${policy.command}` : " FOR ALL";
+  const ALLOWED_RLS_COMMANDS = [
+    "ALL",
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "DELETE"
+  ];
+  const rawCommand = policy.command;
+  if (rawCommand !== void 0 && rawCommand !== null && typeof rawCommand !== "string") {
+    throw new Error(
+      `RLS policy command must be a string, got ${typeof rawCommand}.`
+    );
+  }
+  const rlsCommand = rawCommand ? rawCommand.toUpperCase() : "ALL";
+  if (!ALLOWED_RLS_COMMANDS.includes(
+    rlsCommand
+  )) {
+    throw new Error(
+      `Invalid RLS policy command "${rawCommand}". Must be one of: ${ALLOWED_RLS_COMMANDS.join(", ")}.`
+    );
+  }
+  const forClause = rlsCommand !== "ALL" ? ` FOR ${rlsCommand}` : " FOR ALL";
   const asClause = policy.permissive === false ? " AS RESTRICTIVE" : " AS PERMISSIVE";
   const toClause = policy.roles && policy.roles.length > 0 ? ` TO ${policy.roles.map((r) => quoteRoleName(r)).join(", ")}` : "";
-  if (policy.using) validateSqlExpression(policy.using, "USING expression");
-  if (policy.withCheck)
-    validateSqlExpression(policy.withCheck, "WITH CHECK expression");
-  const usingClause = policy.using ? ` USING (${policy.using})` : "";
-  const withCheckClause = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : "";
+  const usingExpr = policy.using;
+  if (usingExpr !== void 0 && usingExpr !== null && usingExpr !== "") {
+    if (typeof usingExpr !== "string") {
+      throw new Error(
+        `RLS policy USING: expression must be a plain string, got ${typeof usingExpr}.`
+      );
+    }
+    validateSqlExpression(usingExpr, "USING expression");
+  }
+  const withCheckExpr = policy.withCheck;
+  if (withCheckExpr !== void 0 && withCheckExpr !== null && withCheckExpr !== "") {
+    if (typeof withCheckExpr !== "string") {
+      throw new Error(
+        `RLS policy WITH CHECK: expression must be a plain string, got ${typeof withCheckExpr}.`
+      );
+    }
+    validateSqlExpression(withCheckExpr, "WITH CHECK expression");
+  }
+  const usingClause = usingExpr ? ` USING (${usingExpr})` : "";
+  const withCheckClause = withCheckExpr ? ` WITH CHECK (${withCheckExpr})` : "";
   return `CREATE POLICY ${policyName} ON ${qt}${forClause}${asClause}${toClause}${usingClause}${withCheckClause};`;
 }
 function buildSequenceClause(verb, seqName, seq, includeCycleNoCycle = false) {
@@ -10257,8 +10359,9 @@ function generateCreateTableSQL(table, schemaName) {
 ${body}
 )`;
   if (table.partition) {
+    const strategy = assertPartitionStrategy(table.partition.strategy);
     const partCols = table.partition.columns.map((n) => quoteIdent2(n, "alias")).join(", ");
-    sql += ` PARTITION BY ${table.partition.strategy} (${partCols})`;
+    sql += ` PARTITION BY ${strategy} (${partCols})`;
   }
   sql += ";";
   return sql;
@@ -10300,6 +10403,16 @@ function generateTablesPhase(ctx) {
 }
 
 // src/ddl/ddl-generator.ts
+var ALLOWED_PARTITION_STRATEGIES = ["RANGE", "LIST", "HASH"];
+function assertPartitionStrategy(value) {
+  const upper = value.toUpperCase();
+  if (!ALLOWED_PARTITION_STRATEGIES.includes(upper)) {
+    throw new Error(
+      `Invalid partition strategy "${value}". Must be one of: ${ALLOWED_PARTITION_STRATEGIES.join(", ")}.`
+    );
+  }
+  return upper;
+}
 function generateDDL(schema, options = {}) {
   const {
     includeDropStatements = false,
@@ -10379,8 +10492,9 @@ function generateCreateTable(table, schemaName, naming) {
 ${elementsStr}
 )`;
   if (table.partition) {
+    const strategy = assertPartitionStrategy(table.partition.strategy);
     const partCols = table.partition.columns.map((col) => quoteIdentifier(naming.toDatabase(col))).join(", ");
-    sql += ` PARTITION BY ${table.partition.strategy} (${partCols})`;
+    sql += ` PARTITION BY ${strategy} (${partCols})`;
   }
   sql += ";";
   return sql;
@@ -10459,17 +10573,50 @@ function generateCreateIndex(tableName, idx, schemaName, naming) {
 function generateCreatePolicy(tableName, policy, schemaName, naming) {
   const qualifiedTable = qualifyTable2(tableName, schemaName, naming);
   const policyName = quoteIdentifier(policy.name);
-  const forClause = policy.command && policy.command !== "ALL" ? ` FOR ${policy.command}` : " FOR ALL";
+  const ALLOWED_RLS_COMMANDS = [
+    "ALL",
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "DELETE"
+  ];
+  const rawCommand = policy.command;
+  if (rawCommand !== void 0 && rawCommand !== null && typeof rawCommand !== "string") {
+    throw new Error(
+      `RLS policy command must be a string, got ${typeof rawCommand}.`
+    );
+  }
+  const rlsCommand = rawCommand ? rawCommand.toUpperCase() : "ALL";
+  if (!ALLOWED_RLS_COMMANDS.includes(
+    rlsCommand
+  )) {
+    throw new Error(
+      `Invalid RLS policy command "${rawCommand}". Must be one of: ${ALLOWED_RLS_COMMANDS.join(", ")}.`
+    );
+  }
+  const forClause = rlsCommand !== "ALL" ? ` FOR ${rlsCommand}` : " FOR ALL";
   const asClause = policy.permissive === false ? " AS RESTRICTIVE" : " AS PERMISSIVE";
   const toClause = policy.roles && policy.roles.length > 0 ? ` TO ${policy.roles.map((r) => quoteRoleName(r)).join(", ")}` : "";
-  if (policy.using) {
-    validateSqlExpression(policy.using, "policy USING expression");
+  const usingExpr = policy.using;
+  if (usingExpr !== void 0 && usingExpr !== null && usingExpr !== "") {
+    if (typeof usingExpr !== "string") {
+      throw new Error(
+        `RLS policy USING: expression must be a plain string, got ${typeof usingExpr}.`
+      );
+    }
+    validateSqlExpression(usingExpr, "policy USING expression");
   }
-  if (policy.withCheck) {
-    validateSqlExpression(policy.withCheck, "policy WITH CHECK expression");
+  const withCheckExpr = policy.withCheck;
+  if (withCheckExpr !== void 0 && withCheckExpr !== null && withCheckExpr !== "") {
+    if (typeof withCheckExpr !== "string") {
+      throw new Error(
+        `RLS policy WITH CHECK: expression must be a plain string, got ${typeof withCheckExpr}.`
+      );
+    }
+    validateSqlExpression(withCheckExpr, "policy WITH CHECK expression");
   }
-  const usingClause = policy.using ? ` USING (${policy.using})` : "";
-  const withCheckClause = policy.withCheck ? ` WITH CHECK (${policy.withCheck})` : "";
+  const usingClause = usingExpr ? ` USING (${usingExpr})` : "";
+  const withCheckClause = withCheckExpr ? ` WITH CHECK (${withCheckExpr})` : "";
   return `CREATE POLICY ${policyName} ON ${qualifiedTable}${forClause}${asClause}${toClause}${usingClause}${withCheckClause};`;
 }
 
@@ -16163,8 +16310,18 @@ function generateAlterColumnSQL(table, column, options, schema) {
   const statements = [];
   if (options.type !== void 0) {
     const safeType = validateDbTypeName(options.type);
-    const using = options.using !== void 0 ? ` USING ${options.using}` : "";
-    statements.push(`${prefix} TYPE ${safeType}${using}`);
+    const using = options.using;
+    if (using !== void 0) {
+      if (typeof using !== "string") {
+        throw new Error(
+          `ALTER COLUMN USING: expression must be a plain string, got ${typeof using}.`
+        );
+      }
+      validateSqlExpression(using, "ALTER COLUMN USING expression");
+      statements.push(`${prefix} TYPE ${safeType} USING ${using}`);
+    } else {
+      statements.push(`${prefix} TYPE ${safeType}`);
+    }
   }
   if (options.setNotNull === true) {
     statements.push(`${prefix} SET NOT NULL`);