@dbsp/adapter-pgsql 1.10.2 → 1.11.2

package/dist/index.js

@@ -94,8 +94,373 @@ var init_naming_plugin = __esm({
   }
 });
 
+// src/db-type.ts
+function splitDbType(input) {
+  const trimmed = input.trim();
+  let rest = trimmed;
+  let isArray = false;
+  if (rest.endsWith("[]")) {
+    isArray = true;
+    rest = rest.slice(0, -2).trimEnd();
+  }
+  const lowerRest = rest.toLowerCase();
+  for (const suffix of TEMPORAL_TZ_SUFFIXES) {
+    if (!lowerRest.endsWith(suffix)) continue;
+    const beforeSuffix = rest.slice(0, -suffix.length).trimEnd();
+    const temporal = splitTrailingModifier(beforeSuffix);
+    const temporalBase = normalizeBase(temporal.base).toLowerCase();
+    if (temporalBase === "timestamp" || temporalBase === "time") {
+      const base2 = normalizeBase(`${temporal.base}${suffix}`);
+      return {
+        base: base2,
+        modifier: temporal.modifier,
+        isArray,
+        schemaQualified: isSchemaQualified(base2)
+      };
+    }
+  }
+  const split = splitTrailingModifier(rest);
+  const base = normalizeBase(split.base);
+  return {
+    base,
+    modifier: split.modifier,
+    isArray,
+    schemaQualified: isSchemaQualified(base)
+  };
+}
+function splitTrailingModifier(input) {
+  const match = input.match(/^(.*)\(([^()]*)\)$/);
+  if (!match) return { base: input.trim(), modifier: void 0 };
+  return {
+    base: (match[1] ?? "").trimEnd(),
+    modifier: (match[2] ?? "").trim()
+  };
+}
+function normalizeBase(base) {
+  const trimmed = base.trim();
+  return trimmed.includes('"') ? trimmed : trimmed.replace(/\s+/g, " ");
+}
+function isSchemaQualified(base) {
+  return QUALIFIED_IDENTIFIER_RE.test(base);
+}
+function canonicalizeDbType(type) {
+  const split = splitDbType(type);
+  const base = normalizeBase(split.base);
+  const canonicalBase = base.includes('"') ? base : TYPE_ALIASES.get(base.toLowerCase()) ?? base.toLowerCase();
+  const modifier = split.modifier === void 0 ? "" : `(${split.modifier.replace(/\s*,\s*/g, ",").trim()})`;
+  const arraySuffix = split.isArray ? "[]" : "";
+  return `${canonicalBase}${modifier}${arraySuffix}`;
+}
+function dbTypeCastTarget(originalDbType) {
+  const split = splitDbType(originalDbType);
+  const base = normalizeBase(split.base).toLowerCase();
+  const hasModifier = split.modifier !== void 0;
+  const arraySuffix = split.isArray ? "[]" : "";
+  if (base === "varchar" || base === "character varying") {
+    return hasModifier ? `varchar${arraySuffix}` : originalDbType;
+  }
+  if (base === "char" || base === "character" || base === "bpchar") {
+    return `text${arraySuffix}`;
+  }
+  if (base === "bit" || base === "bit varying" || base === "varbit") {
+    return hasModifier ? `bit varying${arraySuffix}` : originalDbType;
+  }
+  if (base === "numeric" || base === "decimal") {
+    return hasModifier ? `numeric${arraySuffix}` : originalDbType;
+  }
+  if (base === "timestamp with time zone" || base === "timestamptz") {
+    return hasModifier ? `timestamp with time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "timestamp without time zone") {
+    return hasModifier ? `timestamp without time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "timestamp") {
+    return hasModifier ? `timestamp without time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "time with time zone" || base === "timetz") {
+    return hasModifier ? `time with time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "time without time zone") {
+    return hasModifier ? `time without time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "time") {
+    return hasModifier ? `time${arraySuffix}` : originalDbType;
+  }
+  if (INTERVAL_BASE_RE.test(base)) {
+    return hasModifier ? `${base}${arraySuffix}` : originalDbType;
+  }
+  return originalDbType;
+}
+function dbTypesEqual(a, b) {
+  return canonicalizeDbType(a) === canonicalizeDbType(b);
+}
+function isPgBuiltInTypeName(type) {
+  const split = splitDbType(type);
+  const base = normalizeBase(split.base);
+  if (base.includes('"') || split.schemaQualified) return false;
+  const baseLower = base.toLowerCase();
+  return MULTIWORD_BASE_TYPES.has(baseLower) || INTERVAL_BASE_RE.test(base) || BUILTIN_BASE_TYPES.has(baseLower);
+}
+function quoteTypeIdentifier(rawIdentifier) {
+  if (SAFE_LOWERCASE_IDENTIFIER_RE.test(rawIdentifier)) return rawIdentifier;
+  return `"${rawIdentifier.replace(/"/g, '""')}"`;
+}
+function unquoteIdentifier(id) {
+  const t = id.trim();
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) {
+    return t.slice(1, -1).replace(/""/g, '"');
+  }
+  return t;
+}
+function enumReferenceKind(originalDbType, typname) {
+  const split = splitDbType(originalDbType);
+  if (split.schemaQualified) return null;
+  if (unquoteIdentifier(normalizeBase(split.base)) !== typname) return null;
+  return split.isArray ? "array" : "scalar";
+}
+function validateDbType(type) {
+  if (typeof type !== "string") {
+    throw new Error(
+      `Unsafe database type name: expected a string, received ${typeof type}`
+    );
+  }
+  if (!isStructurallyValidDbType(type)) {
+    throw new Error(
+      `Unsafe database type name: "${type}". Must be a structurally valid PostgreSQL type name.`
+    );
+  }
+  return type;
+}
+function isStructurallyValidDbType(type) {
+  const trimmed = type.trim();
+  if (trimmed.length === 0 || trimmed !== type) return false;
+  if (/[;]|--|\/\*|\*\//.test(trimmed)) return false;
+  if (trimmed.endsWith("[][]")) return false;
+  if (hasForbiddenTypeKeyword(trimmed)) return false;
+  const split = splitDbType(trimmed);
+  const base = split.base;
+  const baseLower = base.toLowerCase();
+  if (split.modifier !== void 0 && !isSafeModifier(split.modifier, baseLower)) {
+    return false;
+  }
+  if (MULTIWORD_BASE_TYPES.has(baseLower)) {
+    return true;
+  }
+  if (INTERVAL_BASE_RE.test(base)) {
+    return true;
+  }
+  return IDENTIFIER_RE.test(base) || split.schemaQualified;
+}
+function isSafeModifier(modifier, baseLower) {
+  const structurallySafe = modifier.length > 0 && !/[();]|--|\/\*|\*\//.test(modifier) && !MODIFIER_OPERATOR_RE.test(modifier) && MODIFIER_CONTENT_RE.test(modifier) && !hasForbiddenTypeKeyword(modifier);
+  if (!structurallySafe) return false;
+  if (PRECISION_SCALE_BUILTINS.has(baseLower)) {
+    return /^\d+(\s*,\s*-?\d+)?$/.test(modifier);
+  }
+  if (SINGLE_INT_MODIFIER_BUILTINS.has(baseLower) || INTERVAL_BASE_RE.test(baseLower)) {
+    return /^\d+$/.test(modifier.trim());
+  }
+  if (BUILTIN_BASE_TYPES.has(baseLower) || MULTIWORD_BASE_TYPES.has(baseLower)) {
+    return false;
+  }
+  return true;
+}
+function hasForbiddenTypeKeyword(type) {
+  const withoutQuotedIdentifiers = type.replace(QUOTED_IDENTIFIER_RE, '""');
+  return /\bnot\s+null\b|\b(default|references|check|primary|unique|constraint|select|insert|update|delete|drop|alter|create|truncate|grant|revoke|copy)\b/i.test(
+    withoutQuotedIdentifiers
+  );
+}
+var TEMPORAL_TZ_SUFFIXES, SAFE_LOWERCASE_IDENTIFIER_RE, MULTIWORD_BASE_TYPES, TYPE_ALIASES, BUILTIN_BASE_TYPES, UNQUOTED_IDENTIFIER, QUOTED_IDENTIFIER, IDENTIFIER_RE, QUALIFIED_IDENTIFIER_RE, QUOTED_IDENTIFIER_RE, INTERVAL_FIELD, INTERVAL_BASE_RE, MODIFIER_CONTENT_RE, MODIFIER_OPERATOR_RE, SINGLE_INT_MODIFIER_BUILTINS, PRECISION_SCALE_BUILTINS;
+var init_db_type = __esm({
+  "src/db-type.ts"() {
+    "use strict";
+    TEMPORAL_TZ_SUFFIXES = [" without time zone", " with time zone"];
+    SAFE_LOWERCASE_IDENTIFIER_RE = /^[a-z_][a-z0-9_]*$/;
+    MULTIWORD_BASE_TYPES = /* @__PURE__ */ new Set([
+      "timestamp with time zone",
+      "timestamp without time zone",
+      "time with time zone",
+      "time without time zone",
+      "double precision",
+      "character varying",
+      "bit varying"
+    ]);
+    TYPE_ALIASES = /* @__PURE__ */ new Map([
+      ["character varying", "varchar"],
+      ["character", "char"],
+      ["bpchar", "char"],
+      ["bit varying", "varbit"],
+      ["timestamp with time zone", "timestamptz"],
+      ["timestamp without time zone", "timestamp"],
+      ["time with time zone", "timetz"],
+      ["time without time zone", "time"],
+      ["int", "integer"],
+      ["int4", "integer"],
+      ["int8", "bigint"],
+      ["int2", "smallint"],
+      ["float", "double precision"],
+      ["float8", "double precision"],
+      ["float4", "real"],
+      ["bool", "boolean"],
+      ["decimal", "numeric"],
+      ["serial", "integer"],
+      ["serial4", "integer"],
+      ["bigserial", "bigint"],
+      ["serial8", "bigint"],
+      ["smallserial", "smallint"],
+      ["serial2", "smallint"]
+    ]);
+    BUILTIN_BASE_TYPES = /* @__PURE__ */ new Set([
+      ...TYPE_ALIASES.keys(),
+      ...TYPE_ALIASES.values(),
+      "bigint",
+      "bit",
+      "boolean",
+      "box",
+      "bytea",
+      "char",
+      "cidr",
+      "circle",
+      "date",
+      "float",
+      "inet",
+      "integer",
+      "interval",
+      "json",
+      "jsonb",
+      "line",
+      "lseg",
+      "macaddr",
+      "macaddr8",
+      "money",
+      "numeric",
+      "path",
+      "pg_lsn",
+      "point",
+      "polygon",
+      "real",
+      "text",
+      "time",
+      "timestamp",
+      "timetz",
+      "timestamptz",
+      "tsquery",
+      "tsvector",
+      "txid_snapshot",
+      "uuid",
+      "varbit",
+      "varchar",
+      "xml",
+      "jsonpath",
+      "name",
+      "oid",
+      "regclass",
+      "regtype",
+      "regrole",
+      "regnamespace",
+      "regproc",
+      "regprocedure",
+      "xid",
+      "xid8",
+      "cid",
+      "tid",
+      "daterange",
+      "int4range",
+      "int8range",
+      "numrange",
+      "tsrange",
+      "tstzrange",
+      "datemultirange",
+      "int4multirange",
+      "int8multirange",
+      "nummultirange",
+      "tsmultirange",
+      "tstzmultirange"
+    ]);
+    UNQUOTED_IDENTIFIER = "[A-Za-z_][A-Za-z0-9_]*";
+    QUOTED_IDENTIFIER = '"(?:[^"]|"")+"';
+    IDENTIFIER_RE = new RegExp(
+      `^(?:${UNQUOTED_IDENTIFIER}|${QUOTED_IDENTIFIER})$`
+    );
+    QUALIFIED_IDENTIFIER_RE = new RegExp(
+      `^(?:${UNQUOTED_IDENTIFIER}|${QUOTED_IDENTIFIER})\\.(?:${UNQUOTED_IDENTIFIER}|${QUOTED_IDENTIFIER})$`
+    );
+    QUOTED_IDENTIFIER_RE = new RegExp(QUOTED_IDENTIFIER, "g");
+    INTERVAL_FIELD = "(?:year|month|day|hour|minute|second)";
+    INTERVAL_BASE_RE = new RegExp(
+      `^interval(?: ${INTERVAL_FIELD}(?: to ${INTERVAL_FIELD})?)?$`,
+      "i"
+    );
+    MODIFIER_CONTENT_RE = /^[A-Za-z0-9_,.\- ]+$/;
+    MODIFIER_OPERATOR_RE = /[=<>+*/%|&!@#^~]/;
+    SINGLE_INT_MODIFIER_BUILTINS = /* @__PURE__ */ new Set([
+      "varchar",
+      "character varying",
+      "char",
+      "character",
+      "bpchar",
+      // float(p): PostgreSQL treats float(1..24) as real, float(25..53) as double
+      // precision — a single-integer mantissa precision.
+      "float",
+      "bit",
+      "bit varying",
+      "varbit",
+      "timestamp",
+      "timestamptz",
+      "timestamp with time zone",
+      "timestamp without time zone",
+      "time",
+      "timetz",
+      "time with time zone",
+      "time without time zone",
+      "interval"
+    ]);
+    PRECISION_SCALE_BUILTINS = /* @__PURE__ */ new Set(["numeric", "decimal"]);
+  }
+});
+
 // src/validate.ts
+function assertString(value, context) {
+  if (typeof value !== "string") {
+    throw new Error(`${context}: expected a string, received ${typeof value}`);
+  }
+}
+function assertNumericLiteral(value, context) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw new Error(
+      `${context}: expected a finite number or numeric string, received ${typeof value}`
+    );
+  }
+  const literal4 = typeof value === "number" ? String(value) : value;
+  if (typeof value === "number" && !Number.isFinite(value) || !SAFE_DECIMAL_LITERAL.test(literal4)) {
+    throw new Error(`${context}: unsafe numeric literal "${literal4}"`);
+  }
+  return literal4;
+}
+function formatStorageParameterValue(value, context) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw new Error(
+      `${context}: expected a string or number, received ${typeof value}`
+    );
+  }
+  if (typeof value === "number") {
+    return assertNumericLiteral(value, context);
+  }
+  if (value.includes("\0")) {
+    throw new Error(`${context}: contains null byte`);
+  }
+  if (SAFE_DECIMAL_LITERAL.test(value) || SAFE_STORAGE_BOOLEAN_LITERAL.test(value) || SAFE_SIMPLE_IDENTIFIER_VALUE.test(value) && !isReservedKeyword(value) && value.toLowerCase() !== "null") {
+    return value;
+  }
+  return `'${value.replace(/'/g, "''")}'`;
+}
 function validateIdentifier(value, type) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `Invalid ${type} identifier: expected a string, received ${typeof value}`
+    );
+  }
   if (!value || value.length === 0) {
     throw new InvalidIdentifierError(value, type, "cannot be empty");
   }
@@ -171,7 +536,12 @@ function validateIdentifiers(identifiers) {
 function sanitizeForDisplay(value) {
   return value.replace(/[\x00-\x1f\x7f]/g, "?").slice(0, 100);
 }
+function sanitizeCommentText(value) {
+  assertString(value, "SQL comment text");
+  return value.replace(/[\x00-\x1f\x7f]/g, "");
+}
 function validateExtensionName(name, context = "extension") {
+  assertString(name, `Invalid ${context} identifier`);
   if (!name || name.length === 0) {
     throw new InvalidIdentifierError(name, context, "cannot be empty");
   }
@@ -257,6 +627,7 @@ function validateExtensionName(name, context = "extension") {
   }
 }
 function validateCollationName(name, context = "collation") {
+  assertString(name, `Invalid ${context} identifier`);
   if (!name || name.length === 0) {
     throw new InvalidIdentifierError(name, context, "cannot be empty");
   }
@@ -349,24 +720,113 @@ function validateCollationName(name, context = "collation") {
   }
 }
 function validateSqlExpression(sql, context) {
+  assertString(sql, `Unsafe SQL expression in ${context}`);
   if (/[;]|--|\/\*|\*\/|\$\$|\\/.test(sql)) {
     throw new Error(
       `Unsafe SQL expression in ${context}: contains forbidden characters (;, --, /*, */, "$$" (dollar-quoted strings), \\). Value: "${sql}"`
     );
   }
 }
-function validateDbTypeName(type) {
-  if (!SAFE_TYPE_PATTERN.test(type)) {
+function validateCheckExpression(sql, context) {
+  if (typeof sql !== "string") {
     throw new Error(
-      `Unsafe database type name: "${type}". Must match PostgreSQL type name rules.`
+      `Unsafe SQL expression in ${context}: expected a string, received ${typeof sql}`
+    );
+  }
+  let i = 0;
+  let singleQuoted = false;
+  let dollarQuoteDelimiter;
+  while (i < sql.length) {
+    if (singleQuoted) {
+      if (sql[i] === "'") {
+        if (sql[i + 1] === "'") {
+          i += 2;
+          continue;
+        }
+        singleQuoted = false;
+      }
+      i++;
+      continue;
+    }
+    if (dollarQuoteDelimiter) {
+      if (sql.startsWith(dollarQuoteDelimiter, i)) {
+        i += dollarQuoteDelimiter.length;
+        dollarQuoteDelimiter = void 0;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (sql[i] === "'") {
+      singleQuoted = true;
+      i++;
+      continue;
+    }
+    const dollarDelimiter = readDollarQuoteDelimiter(sql, i);
+    if (dollarDelimiter) {
+      dollarQuoteDelimiter = dollarDelimiter;
+      i += dollarDelimiter.length;
+      continue;
+    }
+    const forbiddenToken = forbiddenCheckTokenAt(sql, i);
+    if (forbiddenToken) {
+      throw new Error(
+        `Unsafe SQL expression in ${context}: contains forbidden token "${forbiddenToken}" outside string literal. Value: "${sql}"`
+      );
+    }
+    i++;
+  }
+  if (singleQuoted) {
+    throw new Error(
+      `Unsafe SQL expression in ${context}: unterminated single-quoted string literal. Value: "${sql}"`
+    );
+  }
+  if (dollarQuoteDelimiter) {
+    throw new Error(
+      `Unsafe SQL expression in ${context}: unterminated dollar-quoted string literal ${dollarQuoteDelimiter}. Value: "${sql}"`
     );
   }
-  return type;
 }
-var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_TYPE_PATTERN;
+function forbiddenCheckTokenAt(sql, index) {
+  const ch = sql[index];
+  if (ch === ";" || ch === "\\") return ch;
+  const pair = sql.slice(index, index + 2);
+  if (pair === "--" || pair === "/*" || pair === "*/") return pair;
+  return void 0;
+}
+function readDollarQuoteDelimiter(sql, index) {
+  if (sql[index] !== "$") return void 0;
+  const previous = index > 0 ? sql[index - 1] : void 0;
+  if (previous && isIdentifierContinuationBeforeDollarQuote(previous)) {
+    return void 0;
+  }
+  if (sql[index + 1] === "$") return "$$";
+  if (!isDollarQuoteTagStart(sql[index + 1])) return void 0;
+  let cursor = index + 2;
+  while (isDollarQuoteTagContinuation(sql[cursor])) {
+    cursor++;
+  }
+  if (sql[cursor] !== "$") return void 0;
+  return sql.slice(index, cursor + 1);
+}
+function isIdentifierContinuationBeforeDollarQuote(ch) {
+  return /[A-Za-z0-9_$]/.test(ch) || (ch.codePointAt(0) ?? 0) > 127;
+}
+function isDollarQuoteTagStart(ch) {
+  return ch !== void 0 && /[A-Za-z_]/.test(ch);
+}
+function isDollarQuoteTagContinuation(ch) {
+  return ch !== void 0 && /[A-Za-z0-9_]/.test(ch);
+}
+function validateDbTypeName(type) {
+  assertString(type, "Unsafe database type name");
+  return validateDbType(type);
+}
+var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_DECIMAL_LITERAL, SAFE_STORAGE_BOOLEAN_LITERAL, SAFE_SIMPLE_IDENTIFIER_VALUE;
 var init_validate = __esm({
   "src/validate.ts"() {
     "use strict";
+    init_db_type();
     SQL_RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
       "all",
       "analyse",
@@ -482,7 +942,9 @@ var init_validate = __esm({
       identifierType;
       reason;
     };
-    SAFE_TYPE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])?$/;
+    SAFE_DECIMAL_LITERAL = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)$/;
+    SAFE_STORAGE_BOOLEAN_LITERAL = /^(?:true|false|on|off)$/i;
+    SAFE_SIMPLE_IDENTIFIER_VALUE = /^[A-Za-z_][A-Za-z0-9_]*$/;
   }
 });
 
@@ -1126,7 +1588,7 @@ var init_param_value = __esm({
 });
 
 // src/handlers/expression/case-value.ts
-function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler) {
+function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler, expressionHandler) {
   if (value === null || value === void 0) {
     return nullConstNode();
   }
@@ -1160,7 +1622,8 @@ function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler
         schema,
         naming,
         state,
-        nestedCaseHandler
+        nestedCaseHandler,
+        expressionHandler
       );
       const right = resolveCaseValue(
         expr.right,
@@ -1168,7 +1631,8 @@ function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler
         schema,
         naming,
         state,
-        nestedCaseHandler
+        nestedCaseHandler,
+        expressionHandler
       );
       return {
         A_Expr: {
@@ -1186,15 +1650,29 @@ function resolveCaseValue(value, alias, schema, naming, state, nestedCaseHandler
       }
     // falls through
     default: {
+      if (expressionHandler && typeof expr.kind === "string" && EXPRESSION_HANDLER_KINDS.has(expr.kind)) {
+        return expressionHandler(expr);
+      }
       return bindParameter(value, state);
     }
   }
 }
+var EXPRESSION_HANDLER_KINDS;
 var init_case_value = __esm({
   "src/handlers/expression/case-value.ts"() {
     "use strict";
     init_ast_helpers();
     init_param_value();
+    EXPRESSION_HANDLER_KINDS = /* @__PURE__ */ new Set([
+      "customOp",
+      "customFn",
+      "ref",
+      "cast",
+      "unary",
+      "array",
+      "subquery",
+      "relationColumn"
+    ]);
   }
 });
 
@@ -2752,7 +3230,7 @@ var init_raw_expression_parser = __esm({
 });
 
 // src/compiler-utils.ts
-import { InvalidOperationError, validateTypeName as validateTypeName2 } from "@dbsp/core";
+import { InvalidOperationError } from "@dbsp/core";
 function inferPgArrayType(columnName, columnTypes, sampleValue) {
   if (columnTypes?.[columnName]) {
     const pgBase = mapToPgBaseType(columnTypes[columnName]);
@@ -2770,7 +3248,16 @@ function inferPgArrayType(columnName, columnTypes, sampleValue) {
   return "text[]";
 }
 function mapToPgBaseType(pgType) {
-  const normalized = pgType.toUpperCase().replace(/\(.*\)/, "").trim();
+  const trimmedPgType = pgType.trim();
+  try {
+    validateDbType(trimmedPgType);
+  } catch {
+    throw new Error(
+      `batchValues: invalid type name '${pgType}'. Must be a structurally valid PostgreSQL type name.`
+    );
+  }
+  const elementType = stripArraySuffix(trimmedPgType);
+  const normalized = elementType.toUpperCase().replace(/\(.*\)/, "").trim();
   switch (normalized) {
     // ColumnType aliases (lowercase ColumnType values from ModelIR)
     case "STRING":
@@ -2800,9 +3287,10 @@ function mapToPgBaseType(pgType) {
     case "DOUBLE PRECISION":
     case "FLOAT8":
     case "FLOAT":
+      return "float8";
     case "NUMERIC":
     case "DECIMAL":
-      return "float8";
+      return "numeric";
     case "TEXT":
     case "VARCHAR":
     case "CHAR":
@@ -2822,11 +3310,8 @@ function mapToPgBaseType(pgType) {
       return "timestamptz";
     case "DATE":
       return "date";
-    default: {
-      const customType = pgType.toLowerCase();
-      validateTypeName2(customType);
-      return customType;
-    }
+    default:
+      return elementType;
   }
 }
 function stripArraySuffix(pgArrayType) {
@@ -2875,6 +3360,7 @@ function parseRawExpression(sqlFragment) {
 var init_compiler_utils = __esm({
   "src/compiler-utils.ts"() {
     "use strict";
+    init_db_type();
     init_raw_expression_parser();
   }
 });
@@ -2891,7 +3377,6 @@ var init_param_intent = __esm({
 });
 
 // src/handlers/where/utils.ts
-import { validateTypeName as validateTypeName3 } from "@dbsp/core";
 import { isFieldRef, isParamIntent as isParamIntent3 } from "@dbsp/types";
 function buildColumnRef(column, ctx) {
   if (column.includes(".")) {
@@ -2955,8 +3440,8 @@ function resolveColumnPgType(columnName, ctx) {
   if (!column) return void 0;
   if (column.originalDbType) {
     const typeName = column.originalDbType.trim();
-    validateTypeName3(typeName);
-    return typeName;
+    validateDbType(typeName);
+    return dbTypeCastTarget(typeName);
   }
   return void 0;
 }
@@ -2964,6 +3449,7 @@ var init_utils = __esm({
   "src/handlers/where/utils.ts"() {
     "use strict";
     init_ast_helpers();
+    init_db_type();
     init_param_intent();
     init_param_ref();
     init_types();
@@ -6659,7 +7145,21 @@ var init_arithmetic = __esm({
 // src/handlers/expression/case.ts
 function resolveCaseValue2(value, ctx, state) {
   const alias = ctx.currentAlias ?? ctx.rootTable;
-  return resolveCaseValue(value, alias, void 0, ctx.naming, state);
+  return resolveCaseValue(
+    value,
+    alias,
+    void 0,
+    ctx.naming,
+    state,
+    void 0,
+    // Handler-level path: renders every expression kind via the shared
+    // expression compiler. It does NOT apply the customFn FILTER modifier
+    // (agg_filter) — that requires compiler-private compileFilterCondition,
+    // which cannot be reached here without a circular dependency. The primary
+    // DX caseWhen path (PlanCompiler.compileCustomExpressionNode) filter-patches
+    // correctly; use it for filtered aggregates as CASE branches.
+    (expr) => compileExpressionIntent(expr, ctx, state)
+  );
 }
 var caseHandler, simpleCaseHandler;
 var init_case = __esm({
@@ -6668,6 +7168,7 @@ var init_case = __esm({
     init_ast_helpers();
     init_param_intent();
     init_case_value();
+    init_custom();
     init_param_value();
     caseHandler = {
       types: ["case", "CASE", "caseWhen"],
@@ -9366,6 +9867,24 @@ function renumberNode(value, offset) {
   }
   return result;
 }
+function maxParamRefNumber(value) {
+  if (value === null || typeof value !== "object") return 0;
+  if (Array.isArray(value)) {
+    let max2 = 0;
+    for (const item of value) max2 = Math.max(max2, maxParamRefNumber(item));
+    return max2;
+  }
+  const obj = value;
+  if ("ParamRef" in obj && obj.ParamRef !== null && typeof obj.ParamRef === "object") {
+    const n = obj.ParamRef.number;
+    return typeof n === "number" ? n : 0;
+  }
+  let max = 0;
+  for (const key of Object.keys(obj)) {
+    max = Math.max(max, maxParamRefNumber(obj[key]));
+  }
+  return max;
+}
 var includeHandlersInitialized = false;
 function ensureIncludeHandlersRegistered() {
   if (includeHandlersInitialized) return;
@@ -10400,7 +10919,7 @@ var PlanCompiler = class _PlanCompiler {
       }
       case "selectExpression": {
         if (decision.expressionType === "case") {
-          const caseNode = this.compileCaseExpression(decision);
+          const caseNode = this.compileCaseExpression(decision, plan);
           const alias = decision.alias;
           targetList.push({
             ResTarget: {
@@ -10413,34 +10932,7 @@ var PlanCompiler = class _PlanCompiler {
       }
       case "selectCustomExpression": {
         const exprIntent = decision.expressionIntent;
-        const outerThis = this;
-        const ctx = {
-          ...this.createHandlerContext(plan, plan.rootTable),
-          compileSubquery(query, paramOffset) {
-            return outerThis.compileExpressionSubquery(query, paramOffset);
-          }
-        };
-        const state = this.createHandlerState();
-        const node = compileExpressionIntent(exprIntent, ctx, state);
-        if (exprIntent.kind === "customFn" && exprIntent.filter) {
-          const filterIntent = exprIntent.filter;
-          const filterDecision = convertWhereCondition(
-            filterIntent,
-            plan.rootTable
-          );
-          if (filterDecision) {
-            const filterNode = compileFilterCondition(
-              filterDecision,
-              createWhereDispatcher(),
-              ctx,
-              state
-            );
-            if (filterNode && "FuncCall" in node) {
-              node.FuncCall.agg_filter = filterNode;
-            }
-          }
-        }
-        this.state.paramIndex = state.paramIndex;
+        const node = this.compileCustomExpressionNode(exprIntent, plan);
         const alias = decision.alias || decision.column || void 0;
         targetList.push({
           ResTarget: {
@@ -10707,14 +11199,28 @@ var PlanCompiler = class _PlanCompiler {
    */
   compileJoinDecision(decision, plan, from) {
     if (isPrecompiledJoinDecision(decision)) {
-      if (isBatchValuesJoinDecision(decision)) {
+      const isBatchValues = isBatchValuesJoinDecision(decision);
+      if (isBatchValues) {
         for (const p of decision.batchValuesParams) {
           this.state.parameters.push(p);
         }
         this.state.paramIndex = this.state.parameters.length;
       }
       const jRarg = decision.joinRarg;
-      const jOn = decision.joinOnNode;
+      let jOn = decision.joinOnNode;
+      if (!isBatchValues && decision.joinOnParams?.length) {
+        if (maxParamRefNumber(decision.joinOnNode) > decision.joinOnParams.length) {
+          throw new Error(
+            "Table-mode JOIN ON clauses support only inline param() values; externally pre-assigned or bound parameters in an ON clause are not supported."
+          );
+        }
+        const offset = this.state.parameters.length;
+        jOn = renumberParamRefsInAst(decision.joinOnNode, offset);
+        for (const p of decision.joinOnParams) {
+          this.state.parameters.push(p);
+        }
+        this.state.paramIndex = this.state.parameters.length;
+      }
       from[0] = decision.joinType === "left" ? leftJoin(from[0], jRarg, jOn) : innerJoin(from[0], jRarg, jOn);
     } else {
       from[0] = this.compileJoin(decision, plan, from[0]);
@@ -11008,7 +11514,7 @@ var PlanCompiler = class _PlanCompiler {
   // --------------------------------------------------------------------------
   // CASE Expression Compilation
   // --------------------------------------------------------------------------
-  compileCaseExpression(decision) {
+  compileCaseExpression(decision, plan) {
     const conditions = decision.conditions;
     const elseValue = decision.value;
     if (!conditions || conditions.length === 0) {
@@ -11016,7 +11522,7 @@ var PlanCompiler = class _PlanCompiler {
     }
     const args = conditions.map((cond) => {
       const whenExpr = this.dispatchWhere(cond.when);
-      const thenResult = this.compileCaseValue(cond.then);
+      const thenResult = this.compileCaseValue(cond.then, plan);
       return {
         CaseWhen: {
           expr: whenExpr,
@@ -11026,7 +11532,7 @@ var PlanCompiler = class _PlanCompiler {
     });
     let defresult;
     if (elseValue !== void 0) {
-      defresult = this.compileCaseValue(elseValue);
+      defresult = this.compileCaseValue(elseValue, plan);
     }
     return {
       CaseExpr: {
@@ -11039,26 +11545,66 @@ var PlanCompiler = class _PlanCompiler {
    * Compile a CASE THEN/ELSE value based on its ExpressionIntent kind.
    * Delegates to shared resolveCaseValue with nested CASE support.
    */
-  compileCaseValue(value) {
+  compileCaseValue(value, plan) {
     return resolveCaseValue(
       value,
       this.currentRootTable,
       void 0,
       this.naming,
       this.state,
-      (expr) => this.compileCaseExpression({
-        type: "selectExpression",
-        expressionType: "case",
-        conditions: expr.when.map((wc) => ({
-          when: wc.condition,
-          // biome-ignore lint/suspicious/noThenProperty: intentional
-          then: wc.result
-        })),
-        value: expr.else,
-        table: this.currentRootTable
-      })
+      (expr) => {
+        const nestedDecision = {
+          type: "selectExpression",
+          expressionType: "case",
+          conditions: expr.when.map((wc) => ({
+            when: wc.condition,
+            // biome-ignore lint/suspicious/noThenProperty: intentional
+            then: wc.result
+          })),
+          value: expr.else,
+          table: this.currentRootTable
+        };
+        return this.compileCaseExpression(nestedDecision, plan);
+      },
+      (expr) => this.compileCustomExpressionNode(
+        expr,
+        plan
+      )
     );
   }
+  /**
+   * Compile a custom ExpressionIntent (customFn, customOp, ref, cast, unary,
+   * array, function, subquery, …) to an AST node, applying the customFn FILTER
+   * clause. Shared by the `selectCustomExpression` target path and CASE
+   * THEN/ELSE values so both render the full expression surface identically
+   * (every expression kind + FILTER), rather than one path silently binding
+   * expressions as parameters or dropping FILTER.
+   */
+  compileCustomExpressionNode(exprIntent, plan) {
+    const ctx = this.createHandlerContext(plan, plan.rootTable);
+    const state = this.createHandlerState();
+    const node = compileExpressionIntent(exprIntent, ctx, state);
+    if (exprIntent.kind === "customFn" && exprIntent.filter) {
+      const filterIntent = exprIntent.filter;
+      const filterDecision = convertWhereCondition(
+        filterIntent,
+        plan.rootTable
+      );
+      if (filterDecision) {
+        const filterNode = compileFilterCondition(
+          filterDecision,
+          createWhereDispatcher(),
+          ctx,
+          state
+        );
+        if (filterNode && "FuncCall" in node) {
+          node.FuncCall.agg_filter = filterNode;
+        }
+      }
+    }
+    this.state.paramIndex = state.paramIndex;
+    return node;
+  }
   // --------------------------------------------------------------------------
   // INSERT Compilation
   // --------------------------------------------------------------------------
@@ -11261,6 +11807,9 @@ function compilePlan(plan, options) {
 init_naming_plugin();
 init_validate();
 
+// src/ddl/phases/comments.ts
+init_validate();
+
 // src/ddl/phases/types.ts
 function sup(caps, flag) {
   return !caps || flag === true;
@@ -11281,6 +11830,7 @@ var VALID_INDEX_METHODS = /* @__PURE__ */ new Set([
   "bloom"
 ]);
 function validateIndexMethod(method, context = "index method") {
+  assertString(method, `Invalid ${context}`);
   if (!VALID_INDEX_METHODS.has(method)) {
     throw new Error(
       `Invalid ${context}: "${method}". Must be one of: ${[...VALID_INDEX_METHODS].join(", ")}`
@@ -11288,6 +11838,7 @@ function validateIndexMethod(method, context = "index method") {
   }
 }
 function validateEnumLabel(value, context = "enum label") {
+  assertString(value, `Invalid ${context}`);
   if (/\x00/.test(value)) {
     throw new Error(
       `Invalid ${context}: contains NUL byte (\\x00) which would be silently truncated by PostgreSQL`
@@ -11312,6 +11863,7 @@ function quoteCollation(name) {
   return `"${name}"`;
 }
 function quoteRoleName(name) {
+  assertString(name, "quoteRoleName: role name");
   if (!name) {
     throw new Error("quoteRoleName: role name must not be empty");
   }
@@ -11378,17 +11930,21 @@ function generateCommentsPhase(ctx) {
   }
   const statements = [];
   for (const table of tables) {
-    if (table.comment) {
+    const tableComment = table.comment;
+    if (tableComment) {
+      assertString(tableComment, "table comment");
       const qualifiedTable = qualifyTableIdent(table.name, schemaName, naming);
       statements.push(
-        `COMMENT ON TABLE ${qualifiedTable} IS '${table.comment.replace(/'/g, "''")}';`
+        `COMMENT ON TABLE ${qualifiedTable} IS '${tableComment.replace(/'/g, "''")}';`
       );
     }
     for (const col of table.columns) {
-      if (col.comment) {
+      const columnComment = col.comment;
+      if (columnComment) {
+        assertString(columnComment, "column comment");
         const qualifiedTable = qualifyTableIdent(table.name, schemaName, naming);
         statements.push(
-          `COMMENT ON COLUMN ${qualifiedTable}.${quoteIdent2(naming.toDatabase(col.name))} IS '${col.comment.replace(/'/g, "''")}';`
+          `COMMENT ON COLUMN ${qualifiedTable}.${quoteIdent2(naming.toDatabase(col.name))} IS '${columnComment.replace(/'/g, "''")}';`
         );
       }
     }
@@ -11413,9 +11969,10 @@ function generateConstraintsPhase(ctx) {
       for (const check of table.checkConstraints ?? []) {
         const qualifiedTable = qualifyTableIdent(table.name, schemaName, naming);
         const constraintName = quoteIdent2(check.name);
-        validateSqlExpression(check.expression, "check constraint expression");
+        const expression = check.expression;
+        validateCheckExpression(expression, "check constraint expression");
         statements.push(
-          `ALTER TABLE ${qualifiedTable} ADD CONSTRAINT ${constraintName} ${check.expression};`
+          `ALTER TABLE ${qualifiedTable} ADD CONSTRAINT ${constraintName} ${expression};`
         );
       }
     }
@@ -11525,16 +12082,37 @@ function generateRlsPhase(ctx) {
 init_validate();
 
 // src/ddl/type-mapping.ts
+init_db_type();
 init_validate();
 function mapColumnType(col) {
   if (col.originalDbType) {
-    return validateDbTypeName(col.originalDbType.toUpperCase()).toUpperCase();
+    const originalDbType = validateDbTypeName(col.originalDbType);
+    return isPgBuiltInTypeName(originalDbType) ? uppercaseOutsideQuotedIdentifiers(originalDbType) : originalDbType;
   }
   if (col.autoIncrement) {
     return col.type === "bigint" ? "BIGSERIAL" : "SERIAL";
   }
   return mapBaseType(col.type);
 }
+function uppercaseOutsideQuotedIdentifiers(type) {
+  let result = "";
+  let inQuotedIdentifier = false;
+  for (let i = 0; i < type.length; i++) {
+    const char = type[i];
+    if (char === '"') {
+      result += char;
+      if (inQuotedIdentifier && type[i + 1] === '"') {
+        result += type[i + 1];
+        i++;
+        continue;
+      }
+      inQuotedIdentifier = !inQuotedIdentifier;
+      continue;
+    }
+    result += inQuotedIdentifier ? char : char.toUpperCase();
+  }
+  return result;
+}
 function mapBaseType(type) {
   switch (type) {
     case "string":
@@ -11598,12 +12176,29 @@ function mapOnDeleteAction(action) {
 function qualifyTable(table, schemaName) {
   return schemaName ? `${quoteIdent2(schemaName, "schema")}.${quoteIdent2(table, "table")}` : quoteIdent2(table, "table");
 }
+function buildDoBlock(body) {
+  const delimiter = chooseDoBlockDelimiter(body);
+  return `DO ${delimiter} ${body} ${delimiter};`;
+}
+function chooseDoBlockDelimiter(body) {
+  if (!body.includes("$$")) return "$$";
+  let suffix = 0;
+  let delimiter = "$dbsp_check$";
+  while (body.includes(delimiter)) {
+    suffix++;
+    delimiter = `$dbsp_check_${suffix}$`;
+  }
+  return delimiter;
+}
 function pkName(table) {
   return `pk_${table}`;
 }
 function fkName(table, columns) {
   return `fk_${table}_${columns.join("_")}`;
 }
+function uniqueName(table, column) {
+  return `${table}_${column}_key`;
+}
 function idxName(table, columns, customName) {
   return customName ?? `idx_${table}_${columns.join("_")}`;
 }
@@ -11658,11 +12253,22 @@ function buildPolicySQL(tableName, policy, schemaName) {
 }
 function buildSequenceClause(verb, seqName, seq, includeCycleNoCycle = false) {
   const parts = [`${verb} ${seqName}`];
-  if (seq.startWith !== void 0) parts.push(`START WITH ${seq.startWith}`);
+  if (seq.startWith !== void 0)
+    parts.push(
+      `START WITH ${assertNumericLiteral(seq.startWith, "sequence START WITH")}`
+    );
   if (seq.incrementBy !== void 0)
-    parts.push(`INCREMENT BY ${seq.incrementBy}`);
-  if (seq.minValue !== void 0) parts.push(`MINVALUE ${seq.minValue}`);
-  if (seq.maxValue !== void 0) parts.push(`MAXVALUE ${seq.maxValue}`);
+    parts.push(
+      `INCREMENT BY ${assertNumericLiteral(seq.incrementBy, "sequence INCREMENT BY")}`
+    );
+  if (seq.minValue !== void 0)
+    parts.push(
+      `MINVALUE ${assertNumericLiteral(seq.minValue, "sequence MINVALUE")}`
+    );
+  if (seq.maxValue !== void 0)
+    parts.push(
+      `MAXVALUE ${assertNumericLiteral(seq.maxValue, "sequence MAXVALUE")}`
+    );
   if (includeCycleNoCycle) {
     if (seq.cycle !== void 0) parts.push(seq.cycle ? "CYCLE" : "NO CYCLE");
   } else {
@@ -11672,7 +12278,7 @@ function buildSequenceClause(verb, seqName, seq, includeCycleNoCycle = false) {
 }
 function failSafeUnknownDownChange(kind) {
   return {
-    sql: `-- WARNING: Cannot reverse unsupported SchemaChange kind "${kind}"`,
+    sql: `-- WARNING: Cannot reverse unsupported SchemaChange kind "${sanitizeCommentText(kind)}"`,
     destructive: true
   };
 }
@@ -11734,7 +12340,7 @@ function generateMigrationSQL(diff, options) {
     [],
     // 8: alter column
     [],
-    // 9: add PK
+    // 9: add PK / column UNIQUE constraint
     [],
     // 10: add FK
     [],
@@ -11821,6 +12427,7 @@ function getPhase(kind) {
     case "alter_column_collation":
     case "alter_column_identity":
       return 8;
+    case "alter_column_unique":
     case "add_primary_key":
       return 9;
     case "add_foreign_key":
@@ -11857,7 +12464,7 @@ function upAddColumn(change, schemaName) {
 }
 function upAlterColumnType(change, schemaName) {
   const col = change.meta?.column;
-  const toType = col ? mapColumnType(col) : String(change.meta?.toType);
+  const toType = col ? mapColumnType(col) : validateDbTypeName(change.meta?.toType);
   return `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} TYPE ${toType};`;
 }
 function upAlterColumnNullable(change, schemaName) {
@@ -11872,6 +12479,34 @@ function upAlterColumnDefault(change, schemaName) {
   }
   return `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} SET DEFAULT ${formatDefault(def)};`;
 }
+function addColumnUniqueSQL(table, column, schemaName, constraintName) {
+  const name = constraintName ?? uniqueName(table, column);
+  if (constraintName !== void 0) validateIdentifier(constraintName, "alias");
+  const quotedConstraintName = quoteIdent2(name, "alias");
+  return `ALTER TABLE ${qualifyTable(table, schemaName)} ADD CONSTRAINT ${quotedConstraintName} UNIQUE (${quoteIdent2(column, "alias")});`;
+}
+function dropColumnUniqueSQL(table, column, schemaName, constraintName) {
+  const name = constraintName ?? uniqueName(table, column);
+  if (constraintName !== void 0) validateIdentifier(constraintName, "alias");
+  const quotedConstraintName = quoteIdent2(name, "alias");
+  return `ALTER TABLE ${qualifyTable(table, schemaName)} DROP CONSTRAINT IF EXISTS ${quotedConstraintName};`;
+}
+function upAlterColumnUnique(change, schemaName) {
+  const unique = change.meta?.unique;
+  if (unique === void 0 || !change.column) return void 0;
+  const constraintName = change.meta?.constraintName;
+  return unique ? addColumnUniqueSQL(
+    change.table,
+    change.column,
+    schemaName,
+    constraintName
+  ) : dropColumnUniqueSQL(
+    change.table,
+    change.column,
+    schemaName,
+    constraintName
+  );
+}
 function upAddPrimaryKey(change, schemaName) {
   const columns = change.meta?.columns;
   const pkCols = columns.map((n) => quoteIdent2(n, "alias")).join(", ");
@@ -11900,8 +12535,9 @@ function upCreateIndex(change, schemaName) {
     "alias"
   );
   const unique = idx.unique ? "UNIQUE " : "";
-  if (idx.method) validateIndexMethod(idx.method, "index method");
-  const method = idx.method ? ` USING ${idx.method}` : "";
+  const indexMethod = idx.method;
+  if (indexMethod) validateIndexMethod(indexMethod, "index method");
+  const method = indexMethod ? ` USING ${indexMethod}` : "";
   const colParts = [
     ...(idx.expressions ?? []).map((expr) => {
       validateSqlExpression(expr, "index expression");
@@ -11918,10 +12554,11 @@ function upCreateIndex(change, schemaName) {
   const nullsNotDistinct = idx.unique && idx.nullsNotDistinct ? " NULLS NOT DISTINCT" : "";
   const withParams = idx.with && Object.keys(idx.with).length > 0 ? ` WITH (${Object.entries(idx.with).map(([k, v]) => {
     validateIdentifier(k, "alias");
-    return `${k} = ${v}`;
+    return `${k} = ${formatStorageParameterValue(v, `index WITH parameter "${k}"`)}`;
   }).join(", ")})` : "";
-  if (idx.where) validateSqlExpression(idx.where, "index WHERE predicate");
-  const where = idx.where ? ` WHERE ${idx.where}` : "";
+  const whereExpr = idx.where;
+  if (whereExpr) validateSqlExpression(whereExpr, "index WHERE predicate");
+  const where = whereExpr ? ` WHERE ${whereExpr}` : "";
   return `CREATE ${unique}INDEX IF NOT EXISTS ${indexName} ON ${qualifyTable(change.table, schemaName)}${method} (${cols})${include}${nullsNotDistinct}${withParams}${where};`;
 }
 function upDropIndex(change, schemaName) {
@@ -11937,12 +12574,12 @@ function upDropIndex(change, schemaName) {
 function upAddCheckConstraint(change, schemaName) {
   const check = change.meta?.check;
   if (!check) return void 0;
+  const expression = check.expression;
   const notValid = check.notValid ? " NOT VALID" : "";
-  validateSqlExpression(
-    check.expression,
-    "migration check constraint expression"
+  validateCheckExpression(expression, "migration check constraint expression");
+  return buildDoBlock(
+    "BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + expression + notValid + "; EXCEPTION WHEN duplicate_object THEN NULL; END"
   );
-  return "DO $$ BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + check.expression + notValid + "; EXCEPTION WHEN duplicate_object THEN NULL; END $$;";
 }
 function upValidateConstraint(change, schemaName) {
   const fk = change.meta?.fk;
@@ -11978,9 +12615,12 @@ function upDropEnum(change, schemaName) {
   if (!enumDef) return void 0;
   const enumName = schemaName ? `${quoteIdent2(schemaName, "alias")}.${quoteIdent2(enumDef.name, "alias")}` : quoteIdent2(enumDef.name, "alias");
   const refs = change.meta?.referencingColumns;
-  const alterStatements = refs && refs.length > 0 ? refs.map(
-    (ref) => `ALTER TABLE ${qualifyTable(ref.table, schemaName)} ALTER COLUMN ${quoteIdent2(ref.column, "alias")} TYPE text;`
-  ) : [];
+  const alterStatements = refs && refs.length > 0 ? refs.map((ref) => {
+    const column = quoteIdent2(ref.column, "alias");
+    const targetType = ref.isArray ? "text[]" : "text";
+    const using = ref.isArray ? ` USING ${column}::text[]` : "";
+    return `ALTER TABLE ${qualifyTable(ref.table, schemaName)} ALTER COLUMN ${column} TYPE ${targetType}${using};`;
+  }) : [];
   return [...alterStatements, `DROP TYPE IF EXISTS ${enumName} CASCADE;`].join(
     "\n"
   );
@@ -12011,6 +12651,7 @@ function upAlterColumnIdentity(change, schemaName) {
 function upAddComment(change, schemaName) {
   const comment = change.meta?.comment;
   const target = change.meta?.target;
+  assertString(comment, "migration comment");
   const escaped = comment.replace(/'/g, "''");
   if (target === "table") {
     return `COMMENT ON TABLE ${qualifyTable(change.table, schemaName)} IS '${escaped}';`;
@@ -12038,6 +12679,8 @@ function changeToUpSQL(change, schemaName) {
       return upAlterColumnNullable(change, schemaName);
     case "alter_column_default":
       return upAlterColumnDefault(change, schemaName);
+    case "alter_column_unique":
+      return upAlterColumnUnique(change, schemaName);
     case "add_primary_key":
       return upAddPrimaryKey(change, schemaName);
     case "drop_primary_key":
@@ -12135,7 +12778,7 @@ function changeToDownSQL(change, schemaName) {
       };
     case "drop_table":
       return {
-        sql: `-- WARNING: Cannot reverse drop_table "${change.table}" -- table data was lost`,
+        sql: `-- WARNING: Cannot reverse drop_table "${sanitizeCommentText(change.table)}" -- table data was lost`,
         destructive: true
       };
     case "add_column":
@@ -12145,19 +12788,20 @@ function changeToDownSQL(change, schemaName) {
       };
     case "drop_column":
       return {
-        sql: `-- WARNING: Cannot reverse drop_column "${change.table}"."${change.column}" -- column data was lost`,
+        sql: `-- WARNING: Cannot reverse drop_column "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- column data was lost`,
         destructive: true
       };
     case "alter_column_type": {
       const fromType = change.meta?.fromType;
-      if (!fromType) {
+      if (fromType == null) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_type "${change.table}"."${change.column}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_type "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
           destructive: true
         };
       }
+      const safeFromType = validateDbTypeName(fromType);
       return {
-        sql: `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} TYPE ${fromType};`,
+        sql: `ALTER TABLE ${qualifyTable(change.table, schemaName)} ALTER COLUMN ${quoteIdent2(change.column, "alias")} TYPE ${safeFromType};`,
         destructive: true
       };
     }
@@ -12165,7 +12809,7 @@ function changeToDownSQL(change, schemaName) {
       const oldNullable = change.meta?.oldNullable;
       if (oldNullable === void 0) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_nullable "${change.table}"."${change.column}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_nullable "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12180,7 +12824,7 @@ function changeToDownSQL(change, schemaName) {
       const oldDefault = change.meta?.oldDefault;
       if (oldDefault === void 0) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_default "${change.table}"."${change.column}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_default "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12197,6 +12841,30 @@ function changeToDownSQL(change, schemaName) {
         destructive: false
       };
     }
+    case "alter_column_unique": {
+      const unique = change.meta?.unique;
+      if (unique === void 0 || !change.column) {
+        return {
+          sql: `-- WARNING: Cannot reverse alter_column_unique "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing migration metadata`,
+          destructive: true
+        };
+      }
+      const constraintName = change.meta?.constraintName;
+      return {
+        sql: unique ? dropColumnUniqueSQL(
+          change.table,
+          change.column,
+          schemaName,
+          constraintName
+        ) : addColumnUniqueSQL(
+          change.table,
+          change.column,
+          schemaName,
+          constraintName
+        ),
+        destructive: unique === true
+      };
+    }
     case "add_primary_key": {
       return {
         sql: `ALTER TABLE ${qualifyTable(change.table, schemaName)} DROP CONSTRAINT IF EXISTS ${quoteIdent2(pkName(change.table), "alias")} CASCADE;`,
@@ -12214,7 +12882,7 @@ function changeToDownSQL(change, schemaName) {
         };
       }
       return {
-        sql: `-- WARNING: Cannot reverse drop_primary_key "${change.table}" -- columns unknown`,
+        sql: `-- WARNING: Cannot reverse drop_primary_key "${sanitizeCommentText(change.table)}" -- columns unknown`,
         destructive: true
       };
     }
@@ -12234,7 +12902,7 @@ function changeToDownSQL(change, schemaName) {
       const fk = change.meta?.fk;
       if (!fk) {
         return {
-          sql: `-- WARNING: Cannot reverse drop_foreign_key "${change.table}" -- FK definition was lost`,
+          sql: `-- WARNING: Cannot reverse drop_foreign_key "${sanitizeCommentText(change.table)}" -- FK definition was lost`,
           destructive: true
         };
       }
@@ -12249,7 +12917,7 @@ function changeToDownSQL(change, schemaName) {
       const fk = change.meta?.fk;
       if (!oldFk || !fk) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_foreign_key "${change.table}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_foreign_key "${sanitizeCommentText(change.table)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12279,7 +12947,7 @@ ${add}`, destructive: false };
       const idx = change.meta?.index;
       if (!idx) {
         return {
-          sql: `-- WARNING: Cannot reverse drop_index "${change.table}" -- index definition was lost`,
+          sql: `-- WARNING: Cannot reverse drop_index "${sanitizeCommentText(change.table)}" -- index definition was lost`,
           destructive: true
         };
       }
@@ -12300,12 +12968,12 @@ ${add}`, destructive: false };
     case "drop_check_constraint": {
       const check = change.meta?.check;
       if (!check) return { sql: void 0, destructive: true };
-      validateSqlExpression(
-        check.expression,
-        "migration check constraint (down)"
-      );
+      const expression = check.expression;
+      validateCheckExpression(expression, "migration check constraint (down)");
       return {
-        sql: "DO $$ BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + check.expression + "; EXCEPTION WHEN duplicate_object THEN NULL; END $$;",
+        sql: buildDoBlock(
+          "BEGIN ALTER TABLE " + qualifyTable(change.table, schemaName) + " ADD CONSTRAINT " + quoteIdent2(check.name, "alias") + " " + expression + "; EXCEPTION WHEN duplicate_object THEN NULL; END"
+        ),
         // Allowlisted: re-adds the dropped CHECK constraint from metadata.
         destructive: false
       };
@@ -12323,7 +12991,10 @@ ${add}`, destructive: false };
       const enumDef = change.meta?.enum;
       if (!enumDef) return { sql: void 0, destructive: true };
       const enumName = schemaName ? `${quoteIdent2(schemaName, "alias")}.${quoteIdent2(enumDef.name, "alias")}` : quoteIdent2(enumDef.name, "alias");
-      const values = enumDef.values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+      const values = enumDef.values.map((v) => {
+        validateEnumLabel(v, "enum value");
+        return `'${v.replace(/'/g, "''")}'`;
+      }).join(", ");
       return {
         sql: `CREATE TYPE ${enumName} AS ENUM (${values});`,
         // Allowlisted: re-creates the dropped enum type from metadata.
@@ -12337,7 +13008,7 @@ ${add}`, destructive: false };
       };
     case "alter_column_collation": {
       return {
-        sql: `-- WARNING: Cannot reverse alter_column_collation "${change.table}"."${change.column}" -- previous collation unknown`,
+        sql: `-- WARNING: Cannot reverse alter_column_collation "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- previous collation unknown`,
         destructive: true
       };
     }
@@ -12363,7 +13034,7 @@ ${add}`, destructive: false };
       }
       if (!prevIdentity && !col.identity) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_column_identity "${change.table}"."${change.column}" -- missing previous identity metadata`,
+          sql: `-- WARNING: Cannot reverse alter_column_identity "${sanitizeCommentText(change.table)}"."${sanitizeCommentText(change.column)}" -- missing previous identity metadata`,
           destructive: true
         };
       }
@@ -12390,7 +13061,8 @@ ${add}`, destructive: false };
     case "drop_comment": {
       const target = change.meta?.target;
       const comment = change.meta?.comment;
-      if (typeof comment === "string") {
+      if (comment !== void 0) {
+        assertString(comment, "migration comment");
         const escaped = comment.replace(/'/g, "''");
         if (target === "table") {
           return {
@@ -12407,8 +13079,9 @@ ${add}`, destructive: false };
           };
         }
       }
+      const columnTarget2 = change.column === void 0 ? "" : `."${sanitizeCommentText(change.column)}"`;
       return {
-        sql: `-- WARNING: Cannot reverse drop_comment "${change.table}"${change.column ? `."${change.column}"` : ""} -- comment text was lost`,
+        sql: '-- WARNING: Cannot reverse drop_comment "' + sanitizeCommentText(change.table) + '"' + columnTarget2 + " -- comment text was lost",
         destructive: true
       };
     }
@@ -12442,7 +13115,7 @@ ${add}`, destructive: false };
       const prevSeq = change.meta?.previousSequence;
       if (!prevSeq) {
         return {
-          sql: `-- WARNING: Cannot reverse alter_sequence "${change.table}" -- missing migration metadata`,
+          sql: `-- WARNING: Cannot reverse alter_sequence "${sanitizeCommentText(change.table)}" -- missing migration metadata`,
           destructive: true
         };
       }
@@ -12465,7 +13138,7 @@ ${add}`, destructive: false };
     }
     case "validate_constraint":
       return {
-        sql: `-- VALIDATE CONSTRAINT cannot be reversed in PostgreSQL (table: "${change.table}")`,
+        sql: `-- VALIDATE CONSTRAINT cannot be reversed in PostgreSQL (table: "${sanitizeCommentText(change.table)}")`,
         destructive: true
       };
     case "enable_rls":
@@ -12506,7 +13179,6 @@ function generateDownSQL(diff, options) {
 function generateDownMigrationSQL(diff, options) {
   const schemaName = options?.schemaName;
   const includeDestructive = options?.includeDestructive ?? true;
-  const changes = includeDestructive ? diff.changes : diff.changes.filter((c) => !c.destructive);
   const phases = [
     [],
     // 0: drop FK, drop CHECK
@@ -12527,7 +13199,7 @@ function generateDownMigrationSQL(diff, options) {
     [],
     // 8: alter column
     [],
-    // 9: add PK
+    // 9: add PK / column UNIQUE constraint
     [],
     // 10: add FK
     [],
@@ -12547,7 +13219,7 @@ function generateDownMigrationSQL(diff, options) {
     []
     // 18: CREATE/DROP POLICY
   ];
-  for (const change of changes) {
+  for (const change of diff.changes) {
     const phase = getPhase(change.kind);
     phases[phase].push(change);
   }
@@ -12556,6 +13228,7 @@ function generateDownMigrationSQL(diff, options) {
   for (let i = phases.length - 1; i >= 0; i--) {
     for (const change of phases[i]) {
       const down = changeToDownSQL(change, schemaName);
+      if (!includeDestructive && down.destructive) continue;
       destructive = down.destructive || destructive;
       if (down.sql) statements.push(down.sql);
     }
@@ -12600,7 +13273,10 @@ function generateAddFKSQL(tableName, fk, schemaName) {
   const qualTable = qualifyTable(tableName, schemaName);
   const constraintName = quoteIdent2(fkName(tableName, fk.columns), "alias");
   const fkCols = fk.columns.map((n) => quoteIdent2(n, "alias")).join(", ");
-  const refTable = qualifyTable(fk.references.table, schemaName);
+  const refTable = qualifyTable(
+    fk.references.table,
+    fk.references.schema ?? schemaName
+  );
   const refCols = fk.references.columns.map((n) => quoteIdent2(n, "alias")).join(", ");
   const onDelete = fk.onDelete ? ` ON DELETE ${mapOnDeleteAction(fk.onDelete)}` : "";
   const onUpdate = fk.onUpdate ? ` ON UPDATE ${mapOnDeleteAction(fk.onUpdate)}` : "";
@@ -12686,10 +13362,11 @@ function quoteIdentifier(name) {
   validateIdentifier(name, "alias");
   return `"${name.replace(/"/g, '""')}"`;
 }
-function qualifyTable2(tableName, schemaName, naming) {
+function qualifyTable2(tableName, schemaName, naming, transformSchema = true) {
   const table = quoteIdentifier(naming.toDatabase(tableName));
   if (schemaName) {
-    return `${quoteIdentifier(naming.toDatabase(schemaName))}.${table}`;
+    const schema = transformSchema ? naming.toDatabase(schemaName) : schemaName;
+    return `${quoteIdentifier(schema)}.${table}`;
   }
   return table;
 }
@@ -12760,7 +13437,7 @@ function generateAlterTableAddFK(tableName, fk, schemaName, naming) {
     `fk_${tableName}_${fk.columns.join("_")}`
   );
   const fkCols = fk.columns.map((col) => quoteIdentifier(naming.toDatabase(col))).join(", ");
-  const refTable = qualifyTable2(fk.references.table, schemaName, naming);
+  const refTable = fk.references.schema !== void 0 ? qualifyTable2(fk.references.table, fk.references.schema, naming, false) : qualifyTable2(fk.references.table, schemaName, naming);
   const refCols = fk.references.columns.map((col) => quoteIdentifier(naming.toDatabase(col))).join(", ");
   const onDelete = fk.onDelete ? ` ON DELETE ${mapOnDeleteAction(fk.onDelete)}` : "";
   const onUpdate = fk.onUpdate ? ` ON UPDATE ${mapOnDeleteAction(fk.onUpdate)}` : "";
@@ -12774,8 +13451,9 @@ function generateCreateIndex(tableName, idx, schemaName, naming) {
   );
   const qualifiedTable = qualifyTable2(tableName, schemaName, naming);
   const unique = idx.unique ? "UNIQUE " : "";
-  if (idx.method) validateIndexMethod(idx.method, "index method");
-  const method = idx.method ? ` USING ${idx.method}` : "";
+  const indexMethod = idx.method;
+  if (indexMethod) validateIndexMethod(indexMethod, "index method");
+  const method = indexMethod ? ` USING ${indexMethod}` : "";
   const colParts = [];
   if (idx.expressions && idx.expressions.length > 0) {
     for (const expr of idx.expressions) {
@@ -12795,10 +13473,11 @@ function generateCreateIndex(tableName, idx, schemaName, naming) {
   const nullsNotDistinct = idx.unique && idx.nullsNotDistinct ? " NULLS NOT DISTINCT" : "";
   const withParams = idx.with && Object.keys(idx.with).length > 0 ? ` WITH (${Object.entries(idx.with).map(([k, v]) => {
     validateIdentifier(k, "alias");
-    return `${k} = ${v}`;
+    return `${k} = ${formatStorageParameterValue(v, `index WITH parameter "${k}"`)}`;
   }).join(", ")})` : "";
-  if (idx.where) validateSqlExpression(idx.where, "index WHERE predicate");
-  const where = idx.where ? ` WHERE ${idx.where}` : "";
+  const whereExpr = idx.where;
+  if (whereExpr) validateSqlExpression(whereExpr, "index WHERE predicate");
+  const where = whereExpr ? ` WHERE ${whereExpr}` : "";
   return `CREATE ${unique}INDEX ${indexName} ON ${qualifiedTable}${method} (${cols})${include}${nullsNotDistinct}${withParams}${where};`;
 }
 function generateCreatePolicy(tableName, policy, schemaName, naming) {
@@ -13025,6 +13704,7 @@ async function removeMigrationRecord(pool, name) {
 }
 
 // src/ddl/schema-diff.ts
+init_db_type();
 init_naming_plugin();
 function compareSchemata(schema, db, options) {
   const changes = [];
@@ -13165,7 +13845,8 @@ function normalizeTable(table, plugin) {
       columns: fk.columns.map(toDb),
       references: {
         table: toDb(fk.references.table),
-        columns: fk.references.columns.map(toDb)
+        columns: fk.references.columns.map(toDb),
+        ...fk.references.schema !== void 0 ? { schema: fk.references.schema } : {}
       }
     })),
     indexes: table.indexes.map((idx) => ({
@@ -13211,9 +13892,7 @@ function compareColumns(schema, db, changes) {
   }
 }
 function compareColumnDetails(tableName, schema, db, changes) {
-  const schemaDbType = schema.originalDbType?.toLowerCase();
-  const dbDbType = db.originalDbType?.toLowerCase();
-  if (schemaDbType && dbDbType && schemaDbType !== dbDbType) {
+  if (schema.originalDbType && db.originalDbType && !dbTypesEqual(schema.originalDbType, db.originalDbType)) {
     changes.push({
       kind: "alter_column_type",
       table: tableName,
@@ -13258,6 +13937,21 @@ function compareColumnDetails(tableName, schema, db, changes) {
       meta: { default: schema.default, oldDefault: db.default }
     });
   }
+  const schemaUnique = schema.unique === true;
+  const dbUnique = db.unique === true;
+  if (schemaUnique !== dbUnique) {
+    changes.push({
+      kind: "alter_column_unique",
+      table: tableName,
+      column: schema.name,
+      destructive: schemaUnique === false,
+      details: `Change unique of "${schema.name}" from ${dbUnique} to ${schemaUnique}`,
+      meta: {
+        unique: schemaUnique,
+        ...db.uniqueConstraintName !== void 0 ? { constraintName: db.uniqueConstraintName } : {}
+      }
+    });
+  }
   if ((schema.collation ?? null) !== (db.collation ?? null)) {
     changes.push({
       kind: "alter_column_collation",
@@ -13329,7 +14023,8 @@ function comparePrimaryKeys(schema, db, changes) {
       kind: "drop_primary_key",
       table: schema.name,
       destructive: true,
-      details: `Drop primary key (${dbPK.join(", ")})`
+      details: `Drop primary key (${dbPK.join(", ")})`,
+      meta: { columns: dbPK }
     });
     return;
   }
@@ -13337,7 +14032,8 @@ function comparePrimaryKeys(schema, db, changes) {
     kind: "drop_primary_key",
     table: schema.name,
     destructive: true,
-    details: `Drop primary key (${dbPK.join(", ")})`
+    details: `Drop primary key (${dbPK.join(", ")})`,
+    meta: { columns: dbPK }
   });
   changes.push({
     kind: "add_primary_key",
@@ -13409,7 +14105,7 @@ function compareForeignKeys(schema, db, changes) {
   }
 }
 function fkKey(fk) {
-  return `${fk.columns.join(",")}\u2192${fk.references.table}(${fk.references.columns.join(",")})`;
+  return `${fk.columns.join(",")}\u2192${fk.references.schema ?? ""}.${fk.references.table}(${fk.references.columns.join(",")})`;
 }
 function compareIndexes(schema, db, changes) {
   const explicitIndexCols = new Set(
@@ -13442,16 +14138,15 @@ function compareIndexes(schema, db, changes) {
       });
     }
   }
-  const autoUniqueIndexKeys = new Set(
-    schema.columns.filter((col) => col.unique === true).map(
-      (col) => indexKey({
-        columns: [col.name],
-        unique: true
-      })
-    )
+  const dbColMap = new Map(db.columns.map((col) => [col.name, col]));
+  const autoUniqueIndexColumns = new Set(
+    schema.columns.filter((schemaCol) => {
+      const dbCol = dbColMap.get(schemaCol.name);
+      return dbCol !== void 0 && (schemaCol.unique === true || dbCol.unique === true);
+    }).map((col) => col.name)
   );
   for (const [key, idx] of dbIdxMap) {
-    if (!schemaIdxMap.has(key) && !autoFkIndexKeys.has(key) && !autoUniqueIndexKeys.has(key)) {
+    if (!schemaIdxMap.has(key) && !autoFkIndexKeys.has(key) && !isAutoUniqueIndex(schema.name, idx, autoUniqueIndexColumns)) {
       changes.push({
         kind: "drop_index",
         table: schema.name,
@@ -13462,6 +14157,16 @@ function compareIndexes(schema, db, changes) {
     }
   }
 }
+function isAutoUniqueIndex(tableName, idx, autoUniqueIndexColumns) {
+  if (idx.columns.length !== 1) return false;
+  const column = idx.columns[0];
+  if (column === void 0 || !autoUniqueIndexColumns.has(column)) return false;
+  if (idx.unique !== true) return false;
+  if (idx.name !== void 0 && idx.name !== `${tableName}_${column}_key`) {
+    return false;
+  }
+  return idx.nullsNotDistinct !== true && (idx.method === void 0 || idx.method === "btree") && idx.where === void 0 && (idx.expressions === void 0 || idx.expressions.length === 0) && (idx.include === void 0 || idx.include.length === 0) && (idx.opclass === void 0 || Object.keys(idx.opclass).length === 0) && (idx.with === void 0 || Object.keys(idx.with).length === 0);
+}
 function indexKey(idx) {
   const parts = [
     idx.columns.join(","),
@@ -13658,8 +14363,13 @@ function compareEnums(schema, db, changes) {
       const referencingColumns = [];
       for (const [tableName, tableIR] of db.tables) {
         for (const col of tableIR.columns) {
-          if (col.originalDbType === name) {
-            referencingColumns.push({ table: tableName, column: col.name });
+          const kind = col.originalDbType !== void 0 ? enumReferenceKind(col.originalDbType, name) : null;
+          if (kind !== null) {
+            referencingColumns.push({
+              table: tableName,
+              column: col.name,
+              ...kind === "array" ? { isArray: true } : {}
+            });
           }
         }
       }
@@ -13826,6 +14536,7 @@ function buildSummary(changes) {
       case "alter_column_type":
       case "alter_column_nullable":
       case "alter_column_default":
+      case "alter_column_unique":
         columns.altered++;
         break;
       case "add_primary_key":
@@ -14048,6 +14759,7 @@ function vectorDims(column) {
 
 // src/introspection.ts
 init_assert_field();
+init_db_type();
 import { ModelIRImpl } from "@dbsp/core";
 import { buildRelationKeyFields } from "@dbsp/types";
 function parseExpressionsList(raw) {
@@ -14076,6 +14788,7 @@ async function queryAllCatalogs(pool, schema) {
     pksResult,
     fksResult,
     indexesResult,
+    uniqueColumnsResult,
     enumsResult,
     commentsResult,
     checksResult,
@@ -14083,7 +14796,8 @@ async function queryAllCatalogs(pool, schema) {
     extensionsResult,
     sequencesResult,
     rlsResult,
-    policiesResult
+    policiesResult,
+    formattedColumnTypesResult
   ] = await Promise.all([
     // 1. Columns (including identity and collation)
     pool.query(
@@ -14109,28 +14823,44 @@ async function queryAllCatalogs(pool, schema) {
     // 3. Foreign keys
     pool.query(
       `SELECT
-			   tc.constraint_name,
-			   kcu.table_name AS source_table,
-			   kcu.column_name AS source_column,
-			   ccu.table_name AS target_table,
-			   ccu.column_name AS target_column,
-			   rc.delete_rule,
-			   rc.update_rule,
-			   tc.is_deferrable,
-			   tc.initially_deferred
-			 FROM information_schema.table_constraints tc
-			 JOIN information_schema.key_column_usage kcu
-			   ON tc.constraint_name = kcu.constraint_name
-			   AND tc.table_schema = kcu.table_schema
-			 JOIN information_schema.constraint_column_usage ccu
-			   ON ccu.constraint_name = tc.constraint_name
-			   AND ccu.table_schema = tc.table_schema
-			 JOIN information_schema.referential_constraints rc
-			   ON rc.constraint_name = tc.constraint_name
-			   AND rc.constraint_schema = tc.table_schema
-			 WHERE tc.constraint_type = 'FOREIGN KEY'
-			   AND tc.table_schema = $1
-			 ORDER BY tc.constraint_name, kcu.ordinal_position`,
+			   c.conname AS constraint_name,
+			   source_rel.relname AS source_table,
+			   source_attr.attname AS source_column,
+			   target_ns.nspname AS target_schema,
+			   target_rel.relname AS target_table,
+			   target_attr.attname AS target_column,
+			   CASE c.confdeltype
+			     WHEN 'c' THEN 'CASCADE'
+			     WHEN 'n' THEN 'SET NULL'
+			     WHEN 'd' THEN 'SET DEFAULT'
+			     WHEN 'r' THEN 'RESTRICT'
+			     ELSE 'NO ACTION'
+			   END AS delete_rule,
+			   CASE c.confupdtype
+			     WHEN 'c' THEN 'CASCADE'
+			     WHEN 'n' THEN 'SET NULL'
+			     WHEN 'd' THEN 'SET DEFAULT'
+			     WHEN 'r' THEN 'RESTRICT'
+			     ELSE 'NO ACTION'
+			   END AS update_rule,
+			   CASE WHEN c.condeferrable THEN 'YES' ELSE 'NO' END AS is_deferrable,
+			   CASE WHEN c.condeferred THEN 'YES' ELSE 'NO' END AS initially_deferred
+			 FROM pg_constraint c
+			 JOIN pg_class source_rel ON source_rel.oid = c.conrelid
+			 JOIN pg_namespace source_ns ON source_ns.oid = source_rel.relnamespace
+			 JOIN pg_class target_rel ON target_rel.oid = c.confrelid
+			 JOIN pg_namespace target_ns ON target_ns.oid = target_rel.relnamespace
+			 JOIN LATERAL unnest(c.conkey, c.confkey) WITH ORDINALITY AS cols(source_attnum, target_attnum, ord) ON true
+			 JOIN pg_attribute source_attr
+			   ON source_attr.attrelid = c.conrelid
+			   AND source_attr.attnum = cols.source_attnum
+			 JOIN pg_attribute target_attr
+			   ON target_attr.attrelid = c.confrelid
+			   AND target_attr.attnum = cols.target_attnum
+			 WHERE c.contype = 'f'
+			   AND c.conparentid = 0
+			   AND source_ns.nspname = $1
+			 ORDER BY c.conname, cols.ord`,
       [schema]
     ),
     // 4. Indexes (excluding PK-backing indexes and unique-constraint-backing indexes).
@@ -14194,7 +14924,19 @@ async function queryAllCatalogs(pool, schema) {
 			 ORDER BY t.relname, i.relname`,
       [schema]
     ),
-    // 5. ENUM types
+    // 5. Single-column UNIQUE constraints tracked as ColumnIR.unique
+    pool.query(
+      `SELECT rel.relname AS table_name, att.attname AS column_name, c.conname AS constraint_name
+				 FROM pg_constraint c
+				 JOIN pg_class rel ON rel.oid = c.conrelid
+				 JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+				 JOIN pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = c.conkey[1]
+				 WHERE c.contype = 'u'
+				   AND array_length(c.conkey, 1) = 1
+				   AND ns.nspname = $1`,
+      [schema]
+    ),
+    // 6. ENUM types
     pool.query(
       `SELECT
 			   t.typname AS name,
@@ -14207,7 +14949,7 @@ async function queryAllCatalogs(pool, schema) {
 			 GROUP BY t.typname`,
       [schema]
     ),
-    // 6. Comments (table and column level) from pg_description
+    // 7. Comments (table and column level) from pg_description
     pool.query(
       `SELECT
 			   c.relname AS table_name,
@@ -14221,7 +14963,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND d.objsubid >= 0`,
       [schema]
     ),
-    // 7. CHECK constraints
+    // 8. CHECK constraints
     pool.query(
       `SELECT
 			   c.conname AS name,
@@ -14233,7 +14975,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND n.nspname = $1`,
       [schema]
     ),
-    // 8. Partition configurations
+    // 9. Partition configurations
     pool.query(
       `SELECT
 			   c.relname AS table_name,
@@ -14248,13 +14990,13 @@ async function queryAllCatalogs(pool, schema) {
 			 GROUP BY c.relname, p.partstrat`,
       [schema]
     ),
-    // 9. Installed extensions (no schema param — queries globally; skip plpgsql)
+    // 10. Installed extensions (no schema param — queries globally; skip plpgsql)
     pool.query(
       `SELECT extname AS name
 			 FROM pg_extension
 			 WHERE extname != 'plpgsql'`
     ),
-    // 10. Sequences not backed by SERIAL
+    // 11. Sequences not backed by SERIAL
     pool.query(
       `SELECT s.sequencename AS name, s.start_value, s.increment_by, s.min_value, s.max_value, s.cycle
 			 FROM pg_sequences s
@@ -14265,7 +15007,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND d.objid IS NULL`,
       [schema]
     ),
-    // 11. RLS enabled state per table
+    // 12. RLS enabled state per table
     pool.query(
       `SELECT c.relname AS table_name, c.relrowsecurity AS rls_enabled
 			 FROM pg_class c
@@ -14274,7 +15016,7 @@ async function queryAllCatalogs(pool, schema) {
 			   AND c.relkind = 'r'`,
       [schema]
     ),
-    // 12. Row-Level Security policies
+    // 13. Row-Level Security policies
     pool.query(
       `SELECT
 			   c.relname AS table_name,
@@ -14289,6 +15031,29 @@ async function queryAllCatalogs(pool, schema) {
 			 JOIN pg_namespace n ON n.oid = c.relnamespace
 			 WHERE n.nspname = $1`,
       [schema]
+    ),
+    // 14. Faithful SQL-facing column types via format_type, for two cases:
+    // (a) typmod-bearing columns (atttypmod <> -1) — varchar(120), numeric(10,2),
+    //     timestamptz(3), bit(8), vector(768) — to preserve modifier fidelity (#261);
+    // (b) array columns (typcategory 'A') — so integer[] is stored as `integer[]`
+    //     rather than the internal `_int4` udt_name.
+    // Other columns (plain base types, enums/composites/domains) fall back to
+    // quoteTypeIdentifier(udt_name) in buildTableIR, which keeps a bare typname for
+    // lowercase types and quotes a case-sensitive custom type (`"Money"`).
+    pool.query(
+      `SELECT c.relname AS table_name,
+			        a.attname AS column_name,
+			        format_type(a.atttypid, a.atttypmod) AS db_type
+			 FROM pg_catalog.pg_attribute a
+			 JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+			 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+			 JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+			 WHERE n.nspname = $1
+			   AND c.relkind IN ('r','p','v','m','f')
+			   AND a.attnum > 0
+			   AND NOT a.attisdropped
+			   AND (a.atttypmod <> -1 OR t.typcategory = 'A')`,
+      [schema]
     )
   ]);
   return {
@@ -14296,6 +15061,7 @@ async function queryAllCatalogs(pool, schema) {
     pks: pksResult.rows,
     fks: fksResult.rows,
     indexes: indexesResult.rows,
+    uniqueColumns: uniqueColumnsResult.rows,
     enums: enumsResult.rows,
     comments: commentsResult.rows,
     checks: checksResult.rows,
@@ -14303,7 +15069,8 @@ async function queryAllCatalogs(pool, schema) {
     extensions: extensionsResult.rows,
     sequences: sequencesResult.rows,
     rls: rlsResult.rows,
-    policies: policiesResult.rows
+    policies: policiesResult.rows,
+    formattedColumnTypes: formattedColumnTypesResult.rows
   };
 }
 function buildPartitionMap(rows) {
@@ -14381,6 +15148,21 @@ function buildIndexMap(rows) {
   }
   return result;
 }
+function buildUniqueColumnMap(rows) {
+  const result = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const existing = result.get(row.table_name);
+    if (existing) {
+      existing.set(row.column_name, row.constraint_name);
+    } else {
+      result.set(
+        row.table_name,
+        /* @__PURE__ */ new Map([[row.column_name, row.constraint_name]])
+      );
+    }
+  }
+  return result;
+}
 function buildColumnMap(rows) {
   const result = /* @__PURE__ */ new Map();
   for (const col of rows) {
@@ -14408,14 +15190,16 @@ function buildPKMap(rows) {
 function buildFKMap(rows) {
   const result = /* @__PURE__ */ new Map();
   for (const fk of rows) {
-    const existing = result.get(fk.constraint_name);
+    const key = JSON.stringify([fk.source_table, fk.constraint_name]);
+    const existing = result.get(key);
     if (existing) {
       existing.cols.push(fk.source_column);
       existing.refs.push(fk.target_column);
     } else {
-      result.set(fk.constraint_name, {
+      result.set(key, {
         source: fk.source_table,
         target: fk.target_table,
+        targetSchema: fk.target_schema,
         cols: [fk.source_column],
         refs: [fk.target_column],
         deleteRule: fk.delete_rule,
@@ -14478,13 +15262,25 @@ function buildRLSMaps(rlsRows, policiesRows) {
   }
   return { tableRlsEnabled, tablePolicies };
 }
+function columnTypeMapKey(tableName, columnName) {
+  return `${tableName}\0${columnName}`;
+}
+function buildFormattedColumnTypeMap(rows) {
+  const result = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    result.set(columnTypeMapKey(row.table_name, row.column_name), row.db_type);
+  }
+  return result;
+}
 function buildTableIR(tableName, ctx) {
   const rawCols = ctx.tableColumns.get(tableName) ?? [];
   const pkCols = ctx.tablePKs.get(tableName);
+  const uniqueColumns = ctx.uniqueColumns.get(tableName);
   const columns = rawCols.map((col) => {
     const identity = col.is_identity === "YES" && col.identity_generation ? col.identity_generation === "ALWAYS" ? "always" : "byDefault" : void 0;
     const collation = col.collation_name && col.collation_name !== "default" ? col.collation_name : void 0;
     const colComment = ctx.columnComments.get(`${tableName}.${col.column_name}`) ?? void 0;
+    const uniqueConstraintName = uniqueColumns?.get(col.column_name);
     return {
       name: col.column_name,
       type: mapPgType(col.data_type, col.udt_name),
@@ -14493,7 +15289,14 @@ function buildTableIR(tableName, ctx) {
       // it verbatim (e.g. CURRENT_TIMESTAMP, nextval('seq'::regclass)) instead
       // of quoting it as a string literal.
       ...col.column_default != null ? { default: { sql: col.column_default } } : {},
-      originalDbType: col.udt_name,
+      // format_type output (typmod-bearing + array columns) is already
+      // SQL-facing; the udt_name fallback is a bare catalog typname, so
+      // quote it when case-sensitive (`"Money"`) — a lowercase typname
+      // stays bare, preserving the common enum/UDT identity.
+      originalDbType: ctx.formattedColumnTypes.get(
+        columnTypeMapKey(tableName, col.column_name)
+      ) ?? quoteTypeIdentifier(col.udt_name),
+      ...uniqueConstraintName !== void 0 ? { unique: true, uniqueConstraintName } : {},
       ...collation ? { collation } : {},
       ...identity ? { identity } : {},
       ...colComment ? { comment: colComment } : {}
@@ -14502,12 +15305,17 @@ function buildTableIR(tableName, ctx) {
   const foreignKeys = [];
   for (const [, fk] of ctx.fksByConstraint) {
     if (fk.source !== tableName) continue;
-    if (!ctx.tableNames.includes(fk.target)) continue;
+    const isCrossSchema = fk.targetSchema !== void 0 && fk.targetSchema !== ctx.schema;
+    if (!isCrossSchema && !ctx.tableNames.includes(fk.target)) continue;
     const onDelete = mapDeleteRule(fk.deleteRule);
     const onUpdate = mapDeleteRule(fk.updateRule);
     foreignKeys.push({
       columns: fk.cols,
-      references: { table: fk.target, columns: fk.refs },
+      references: {
+        table: fk.target,
+        columns: fk.refs,
+        ...isCrossSchema ? { schema: fk.targetSchema } : {}
+      },
       ...onDelete !== "NO ACTION" ? { onDelete } : {},
       ...onUpdate !== "NO ACTION" ? { onUpdate } : {},
       ...fk.deferred ? { deferred: true } : {}
@@ -14555,7 +15363,11 @@ async function introspect(pool, options) {
   const tablePartitions = buildPartitionMap(raw.partitions);
   const tableChecks = buildCheckMap(raw.checks);
   const tableIndexes = buildIndexMap(raw.indexes);
+  const uniqueColumns = buildUniqueColumnMap(raw.uniqueColumns);
   const tableColumns = buildColumnMap(raw.columns);
+  const formattedColumnTypes = buildFormattedColumnTypeMap(
+    raw.formattedColumnTypes
+  );
   const tablePKs = buildPKMap(raw.pks);
   const fksByConstraint = buildFKMap(raw.fks);
   const enumMap = buildEnumMap(raw.enums);
@@ -14570,9 +15382,11 @@ async function introspect(pool, options) {
   for (const tableName of tableNames) {
     const table = buildTableIR(tableName, {
       tableColumns,
+      formattedColumnTypes,
       tablePKs,
       fksByConstraint,
       tableIndexes,
+      uniqueColumns,
       tableChecks,
       tableComments,
       columnComments,
@@ -14580,20 +15394,33 @@ async function introspect(pool, options) {
       tableRlsEnabled,
       tablePolicies,
       tableNames,
+      schema,
       warnings
     });
     tables.set(tableName, table);
   }
   const extensions = raw.extensions.map((r) => r.name);
   const sequenceMap = buildSequenceMap(raw.sequences);
-  const relations = inferRelations(fksByConstraint, tableNames);
-  const hierarchies = detectHierarchies(tables, fksByConstraint, tableNames);
+  const relations = inferRelations(fksByConstraint, tableNames, schema);
+  const hierarchies = detectHierarchies(
+    tables,
+    fksByConstraint,
+    tableNames,
+    schema
+  );
+  const externalTables = /* @__PURE__ */ new Set();
+  for (const fk of fksByConstraint.values()) {
+    if (fk.targetSchema !== void 0 && fk.targetSchema !== schema && !tables.has(fk.target)) {
+      externalTables.add(fk.target);
+    }
+  }
   const modelIR = new ModelIRImpl(
     tables,
     relations,
     enumMap,
     extensions,
-    sequenceMap
+    sequenceMap,
+    externalTables
   );
   return Object.assign(modelIR, {
     hierarchies,
@@ -14601,10 +15428,11 @@ async function introspect(pool, options) {
     warnings
   });
 }
-function inferRelations(fksByConstraint, filteredTables) {
+function inferRelations(fksByConstraint, filteredTables, schema) {
   const relations = /* @__PURE__ */ new Map();
   const filteredSet = new Set(filteredTables);
   for (const [, fk] of fksByConstraint) {
+    if (fk.targetSchema !== void 0 && fk.targetSchema !== schema) continue;
     if (!filteredSet.has(fk.source) || !filteredSet.has(fk.target)) continue;
     const belongsToName = deriveRelationName(fk.cols[0], fk.target);
     const relationFk = {
@@ -14654,13 +15482,14 @@ function deriveRelationName(fkColumn, _targetTable) {
   }
   return fkColumn;
 }
-function detectHierarchies(tables, fksByConstraint, filteredTables) {
+function detectHierarchies(tables, fksByConstraint, filteredTables, schema) {
   const hierarchies = [];
   const filteredSet = new Set(filteredTables);
   const fksBySourceTarget = /* @__PURE__ */ new Map();
   for (const [, fk] of fksByConstraint) {
+    if (fk.targetSchema !== void 0 && fk.targetSchema !== schema) continue;
     if (!filteredSet.has(fk.source) || !filteredSet.has(fk.target)) continue;
-    if (fk.source === fk.target && fk.cols.length === 1) {
+    if (fk.source === fk.target && fk.cols.length === 1 && (fk.targetSchema === void 0 || fk.targetSchema === schema)) {
       const table = tables.get(fk.source);
       const pk = table?.primaryKey;
       const nodeIdColumn = typeof pk === "string" ? pk : pk?.[0] ?? DEFAULT_PK_COLUMN;
@@ -15601,11 +16430,7 @@ init_naming_plugin();
 init_param_ref();
 
 // src/pgsql-adapter.ts
-import {
-  POSTGRESQL_CAPABILITIES as POSTGRESQL_CAPABILITIES2,
-  plan as planFn2,
-  validateTypeName as validateTypeName4
-} from "@dbsp/core";
+import { POSTGRESQL_CAPABILITIES as POSTGRESQL_CAPABILITIES2, plan as planFn2 } from "@dbsp/core";
 import { getNqlBindingRefName as getNqlBindingRefName2, isNqlBindingRef as isNqlBindingRef2 } from "@dbsp/types/internal";
 
 // src/adapter-compiler-includes.ts
@@ -15825,6 +16650,7 @@ init_compile_where();
 import { countDistinctRelationPathsByName } from "@dbsp/core";
 import { toColumnList as toColumnList10 } from "@dbsp/types";
 init_compiler_utils();
+init_db_type();
 init_types();
 init_intent_to_decisions();
 init_param_ref();
@@ -16727,16 +17553,6 @@ function buildIncludeTree(allDecisions) {
 }
 
 // src/adapter-compiler-select.ts
-var ADAPTER_MULTIWORD_BASE_TYPES = [
-  "timestamp with time zone",
-  "timestamp without time zone",
-  "time with time zone",
-  "time without time zone",
-  "double precision",
-  "character varying",
-  "bit varying"
-];
-var ADAPTER_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function assertSafeTypeName(typeName, colIndex) {
   const raw = typeName.trim();
   if (raw.length === 0) {
@@ -16744,42 +17560,14 @@ function assertSafeTypeName(typeName, colIndex) {
       `BatchValues compile error: type name at column index ${colIndex} must not be empty.`
     );
   }
-  let rest = raw;
-  if (rest.endsWith("[]")) {
-    rest = rest.slice(0, -2);
-    if (rest.endsWith("[]")) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. At most one array suffix "[]" is allowed as a raw type-name input.`
-      );
-    }
-  }
-  const modifierMatch = rest.match(/\(([^)]*)\)$/);
-  if (modifierMatch) {
-    const inner = modifierMatch[1] ?? "";
-    if (!/^\d+(?:,\d+)?$/.test(inner)) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Type modifier must be "(N)" or "(N,M)" with digits only; got "(${inner})".`
-      );
-    }
-    rest = rest.slice(0, rest.length - modifierMatch[0].length).trimEnd();
-  }
-  const baseLower = rest.toLowerCase();
-  if (ADAPTER_MULTIWORD_BASE_TYPES.includes(baseLower)) {
-    return;
-  }
-  const parts = rest.split(".");
-  if (parts.length > 2) {
+  try {
+    validateDbType(raw);
+  } catch (error) {
+    const reason = error instanceof Error ? ` ${error.message}` : "";
     throw new Error(
-      `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Schema-qualified types allow at most one dot (schema.type).`
+      `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}.${reason}`
     );
   }
-  for (const part of parts) {
-    if (!ADAPTER_IDENT_RE.test(part)) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Base type "${part}" is not a valid SQL identifier and is not in the multi-word type allowlist.`
-      );
-    }
-  }
 }
 function buildBatchValuesRangeFn(bv, startParamIndex, aliasOverride) {
   const params = [];
@@ -16935,14 +17723,16 @@ function compileJoinIntents(joins, rootTable, schemaName, deps) {
         schemaForFromName(schemaName, intent.table, deps.bindingNames, naming),
         naming
       );
-      results.push({
+      const joinDecision = {
         type: "join",
         targetTable: intent.table,
         alias: tableAlias,
         joinType: intent.type,
         joinRarg: joinedRangeVar,
-        joinOnNode: onNode
-      });
+        joinOnNode: onNode,
+        joinOnParams: paramState.parameters
+      };
+      results.push(joinDecision);
     }
   }
   return results;
@@ -17240,6 +18030,7 @@ function compileWithIncludes(plan, options, deps) {
 init_binding_registry();
 init_compile_where();
 init_compiler_utils();
+init_db_type();
 init_handlers();
 init_cte_compiler();
 function whereIntentAsDecision(where) {
@@ -17352,7 +18143,14 @@ function getColumnTypes(tableName, columns, deps) {
     const columnIR = table.columns.find((c) => c.name === col);
     if (columnIR) {
       result ??= {};
-      result[col] = columnIR.originalDbType ?? columnIR.type;
+      const authored = columnIR.originalDbType?.trim();
+      const castTarget = authored !== void 0 && authored !== "" ? dbTypeCastTarget(validateDbType(authored)) : columnIR.type;
+      if (castTarget.trim().endsWith("[]")) {
+        throw new Error(
+          `Batch mutation of array-typed column '${col}' (${castTarget}) is not supported: unnest flattens multi-dimensional arrays. Use single-row mutations for array columns.`
+        );
+      }
+      result[col] = castTarget;
     }
   }
   return result;
@@ -18139,6 +18937,7 @@ function buildRecursiveAnchorWhere(where, tableAlias, deps, state) {
 init_assert_field();
 init_ast_helpers();
 init_binding_registry();
+init_db_type();
 
 // src/ddl/index-operations.ts
 init_validate();
@@ -18149,8 +18948,9 @@ function qualifyTable3(table, schema) {
   return schema ? `${quoteIdent2(schema, "schema")}.${quoteIdent2(table, "table")}` : quoteIdent2(table, "table");
 }
 function generateCreateIndexSQL(table, options, schema) {
-  if (options.method !== void 0) {
-    validateIndexMethod(options.method, "index method");
+  const indexMethod = options.method;
+  if (indexMethod !== void 0) {
+    validateIndexMethod(indexMethod, "index method");
   }
   const parts = ["CREATE"];
   if (options.unique) parts.push("UNIQUE");
@@ -18159,8 +18959,8 @@ function generateCreateIndexSQL(table, options, schema) {
   if (options.ifNotExists) parts.push("IF NOT EXISTS");
   parts.push(quoteIdentifier2(options.name));
   parts.push(`ON ${qualifyTable3(table, schema)}`);
-  if (options.method) {
-    parts.push(`USING ${options.method}`);
+  if (indexMethod) {
+    parts.push(`USING ${indexMethod}`);
   }
   const colParts = [];
   for (const col of options.columns) {
@@ -18177,13 +18977,14 @@ function generateCreateIndexSQL(table, options, schema) {
   if (options.with && Object.keys(options.with).length > 0) {
     const withParams = Object.entries(options.with).map(([k, v]) => {
       validateIdentifier(k, "alias");
-      return `${k} = ${v}`;
+      return `${k} = ${formatStorageParameterValue(v, `index WITH parameter "${k}"`)}`;
     }).join(", ");
     parts.push(`WITH (${withParams})`);
   }
-  if (options.where) {
-    validateSqlExpression(options.where, "index WHERE predicate");
-    parts.push(`WHERE ${options.where}`);
+  const whereExpr = options.where;
+  if (whereExpr) {
+    validateSqlExpression(whereExpr, "index WHERE predicate");
+    parts.push(`WHERE ${whereExpr}`);
   }
   return parts.join(" ");
 }
@@ -18194,10 +18995,11 @@ function buildColumnPart(col, opclassMap) {
     if (opclass2) validateIdentifier(opclass2, "alias");
     return opclass2 ? `${quoted} ${opclass2}` : quoted;
   }
-  validateSqlExpression(col.expression, "index expression");
+  const expression = col.expression;
+  validateSqlExpression(expression, "index expression");
   const opclass = col.opclass;
   if (opclass) validateIdentifier(opclass, "alias");
-  return opclass ? `${col.expression} ${opclass}` : col.expression;
+  return opclass ? `${expression} ${opclass}` : expression;
 }
 function generateDropIndexSQL(name, options) {
   const parts = ["DROP INDEX"];
@@ -18589,7 +19391,8 @@ function resolveRuntimeBindingColumnType(bindingName, sourceTable, columnName) {
       `NQL runtime binding '${bindingName}' cannot resolve projected column '${columnName}' on source table '${sourceTable.name}'.`
     );
   }
-  const dbType = column.originalDbType?.trim() || mapRuntimeBindingColumnType(column.type);
+  const originalDbType = column.originalDbType?.trim();
+  const dbType = originalDbType || mapRuntimeBindingColumnType(column.type);
   if (dbType === void 0 || dbType.trim() === "") {
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${columnName}' on source table '${sourceTable.name}'.`
@@ -18597,14 +19400,14 @@ function resolveRuntimeBindingColumnType(bindingName, sourceTable, columnName) {
   }
   const typeName = dbType.trim();
   try {
-    validateTypeName4(typeName);
+    validateDbType(typeName);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${columnName}': ${reason}`
     );
   }
-  return typeName;
+  return originalDbType !== void 0 ? dbTypeCastTarget(typeName) : typeName;
 }
 function resolveRuntimeBindingColumnTypes(name, binding, model, sourceTableName) {
   if (model === void 0) {
@@ -18638,7 +19441,8 @@ function resolvePgTypeForColumnTypeInfo(bindingName, column, info) {
       `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}': unsupported aggregate kind '${String(info.fn)}'.`
     );
   }
-  const rawType = info.kind === "aggregate" ? "bigint" : info.originalDbType?.trim() || mapRuntimeBindingColumnType(info.type);
+  const originalDbType = info.kind === "aggregate" ? void 0 : info.originalDbType?.trim();
+  const rawType = info.kind === "aggregate" ? "bigint" : originalDbType || mapRuntimeBindingColumnType(info.type);
   if (rawType === void 0 || rawType.trim() === "") {
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}'.`
@@ -18646,14 +19450,14 @@ function resolvePgTypeForColumnTypeInfo(bindingName, column, info) {
   }
   const typeName = rawType.trim();
   try {
-    validateTypeName4(typeName);
+    validateDbType(typeName);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${column}': ${reason}`
     );
   }
-  return typeName;
+  return originalDbType !== void 0 ? dbTypeCastTarget(typeName) : typeName;
 }
 function resolveRuntimeBindingCteColumnTypes(name, binding) {
   const columnTypes = binding.columnTypes;