@yawlabs/postgres-mcp 0.10.0 → 0.11.0

package/dist/index.js

@@ -3114,7 +3114,25 @@ var require_utils = __commonJS({
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+    var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+    var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+    var BYTE_HEX = new Array(256);
+    {
+      const HEX_DIGITS = "0123456789ABCDEF";
+      for (let i = 0; i < 256; i++) {
+        BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+      }
+    }
+    function percentEncodeNonAscii(cp) {
+      if (cp < 2048) {
+        return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+      }
+      if (cp < 65536) {
+        return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+      }
+      return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3139,91 +3157,105 @@ var require_utils = __commonJS({
       }
       return acc;
     }
+    var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+    var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+    var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
     var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-    function consumeIsZone(buffer) {
-      buffer.length = 0;
-      return true;
-    }
-    function consumeHextets(buffer, address, output) {
-      if (buffer.length) {
-        const hex3 = stringArrayToHexStripped(buffer);
-        if (hex3 !== "") {
-          address.push(hex3);
-        } else {
-          output.error = true;
-          return false;
+    function isZoneIdentifier(zone) {
+      if (zone.length === 0) return false;
+      for (let i = 0; i < zone.length; i++) {
+        if (isZoneCharacter(zone[i])) continue;
+        if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+          i += 2;
+          continue;
         }
-        buffer.length = 0;
+        return false;
       }
       return true;
     }
-    function getIPV6(input) {
-      let tokenCount = 0;
-      const output = { error: false, address: "", zone: "" };
-      const address = [];
-      const buffer = [];
-      let endipv6Encountered = false;
-      let endIpv6 = false;
-      let consume = consumeHextets;
-      for (let i = 0; i < input.length; i++) {
-        const cursor = input[i];
-        if (cursor === "[" || cursor === "]") {
-          continue;
-        }
-        if (cursor === ":") {
-          if (endipv6Encountered === true) {
-            endIpv6 = true;
-          }
-          if (!consume(buffer, address, output)) {
-            break;
+    function compressIPv6ZeroRun(hextets) {
+      let bestStart = -1;
+      let bestLength = 0;
+      let runStart = -1;
+      let runLength = 0;
+      for (let i = 0; i < hextets.length; i++) {
+        if (hextets[i] === "0") {
+          if (runStart === -1) runStart = i;
+          runLength++;
+          if (runLength > bestLength) {
+            bestLength = runLength;
+            bestStart = runStart;
           }
-          if (++tokenCount > 7) {
-            output.error = true;
-            break;
-          }
-          if (i > 0 && input[i - 1] === ":") {
-            endipv6Encountered = true;
-          }
-          address.push(":");
-          continue;
-        } else if (cursor === "%") {
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          consume = consumeIsZone;
         } else {
-          buffer.push(cursor);
+          runStart = -1;
+          runLength = 0;
+        }
+      }
+      if (bestLength < 2) return hextets.join(":");
+      const head = hextets.slice(0, bestStart).join(":");
+      const tail = hextets.slice(bestStart + bestLength).join(":");
+      return head + "::" + tail;
+    }
+    function normalizeIPv6Address(input) {
+      const compression = input.indexOf("::");
+      if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+      const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+      const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+      if (compression !== -1) {
+        if (left.length === 1 && left[0] === "") left.length = 0;
+        if (right.length === 1 && right[0] === "") right.length = 0;
+      }
+      const parts = left.concat(right);
+      let hextetCount = 0;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "") return void 0;
+        if (part.indexOf(".") !== -1) {
+          if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+          hextetCount += 2;
           continue;
         }
+        if (!isHextet(part)) return void 0;
+        parts[i] = parseInt(part, 16).toString(16);
+        hextetCount++;
       }
-      if (buffer.length) {
-        if (consume === consumeIsZone) {
-          output.zone = buffer.join("");
-        } else if (endIpv6) {
-          address.push(buffer.join(""));
-        } else {
-          address.push(stringArrayToHexStripped(buffer));
-        }
+      if (compression === -1) {
+        if (hextetCount !== 8) return void 0;
+        return compressIPv6ZeroRun(parts);
       }
-      output.address = address.join("");
-      return output;
+      if (hextetCount >= 8) return void 0;
+      const expanded = parts.slice(0, left.length);
+      for (let i = hextetCount; i < 8; i++) expanded.push("0");
+      for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+      return compressIPv6ZeroRun(expanded);
     }
     function normalizeIPv6(host) {
-      if (findToken(host, ":") < 2) {
-        return { host, isIPV6: false };
-      }
-      const ipv63 = getIPV6(host);
-      if (!ipv63.error) {
-        let newHost = ipv63.address;
-        let escapedHost = ipv63.address;
-        if (ipv63.zone) {
-          newHost += "%" + ipv63.zone;
-          escapedHost += "%25" + ipv63.zone;
-        }
-        return { host: newHost, isIPV6: true, escapedHost };
-      } else {
-        return { host, isIPV6: false };
-      }
+      const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+      const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+      if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
+      let input = bracketed ? host.slice(1, -1) : host;
+      if (bracketed && isIPvFuture(input)) {
+        input = input.toLowerCase();
+        return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+      }
+      if (findToken(input, ":") < 2) {
+        return { host, isIPV6: false, error: bracketed };
+      }
+      let zoneIdentifier = "";
+      const zoneSeparator = input.indexOf("%");
+      if (zoneSeparator !== -1) {
+        const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+        zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+        if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
+        input = input.slice(0, zoneSeparator);
+      }
+      const address = normalizeIPv6Address(input);
+      if (address === void 0) return { host, isIPV6: false, error: true };
+      return {
+        host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+        escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+        isIPV6: true
+      };
     }
     function findToken(str, token) {
       let ind = 0;
@@ -3342,7 +3374,8 @@ var require_utils = __commonJS({
     function normalizePathEncoding(input) {
       let output = "";
       for (let i = 0; i < input.length; i++) {
-        if (input[i] === "%" && i + 2 < input.length) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
           const hex3 = input.slice(i + 1, i + 3);
           if (isHexPair(hex3)) {
             const normalizedHex = hex3.toUpperCase();
@@ -3356,10 +3389,152 @@ var require_utils = __commonJS({
             continue;
           }
         }
-        if (isPathCharacter(input[i])) {
-          output += input[i];
+        if (isPathCharacter(ch)) {
+          output += ch;
         } else {
-          output += escape(input[i]);
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function serializePathEncoding(input, pathNoScheme = false) {
+      let output = "";
+      let firstSegment = pathNoScheme && input[0] !== "/";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        if (ch === "/") {
+          firstSegment = false;
+        }
+        if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeComponent(input, isAllowed) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        if (isAllowed(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeUserinfo(input) {
+      return encodeComponent(input, isUserinfoCharacter);
+    }
+    function encodeQuery(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function encodeFragment(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function isEscapeSafe(cp) {
+      return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+    }
+    function normalizeQueryFragmentEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isQueryFragmentCharacter(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
         }
       }
       return output;
@@ -3382,14 +3557,18 @@ var require_utils = __commonJS({
     function recomposeAuthority(component) {
       const uriTokens = [];
       if (component.userinfo !== void 0) {
-        uriTokens.push(component.userinfo);
+        uriTokens.push(encodeUserinfo(component.userinfo));
         uriTokens.push("@");
       }
       if (component.host !== void 0) {
-        let host = unescape(component.host);
+        let host = component.host;
         if (!isIPv4(host)) {
-          const ipV6res = normalizeIPv6(host);
-          if (ipV6res.isIPV6 === true) {
+          let ipV6res = normalizeIPv6(host);
+          if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+            host = normalizePercentEncoding(host, true);
+            ipV6res = normalizeIPv6(host);
+          }
+          if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
             host = reescapeHostDelimiters(host, false);
@@ -3409,6 +3588,11 @@ var require_utils = __commonJS({
       reescapeHostDelimiters,
       normalizePercentEncoding,
       normalizePathEncoding,
+      serializePathEncoding,
+      normalizeQueryFragmentEncoding,
+      encodeUserinfo,
+      encodeQuery,
+      encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
@@ -3424,7 +3608,7 @@ var require_schemes = __commonJS({
   "node_modules/fast-uri/lib/schemes.js"(exports, module) {
     "use strict";
     var { isUUID } = require_utils();
-    var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+    var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
     var supportedSchemeNames = (
       /** @type {const} */
       [
@@ -3485,9 +3669,10 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path, query] = wsComponent.resourceName.split("?");
+        const queryIndex = wsComponent.resourceName.indexOf("?");
+        const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
         wsComponent.path = path && path !== "/" ? path : void 0;
-        wsComponent.query = query;
+        wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
       wsComponent.fragment = void 0;
@@ -3499,7 +3684,7 @@ var require_schemes = __commonJS({
         return urnComponent;
       }
       const matches = urnComponent.path.match(URN_REG);
-      if (matches) {
+      if (matches && matches[0] === urnComponent.path) {
         const scheme = options.scheme || urnComponent.scheme || "urn";
         urnComponent.nid = matches[1].toLowerCase();
         urnComponent.nss = matches[2];
@@ -3633,8 +3818,17 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
+    var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+    var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+    function decodeValidScheme(scheme) {
+      const decodedScheme = unescape(String(scheme));
+      if (!VALID_SCHEME.test(decodedScheme)) {
+        throw new TypeError(MALFORMED_SCHEME_ERROR);
+      }
+      return decodedScheme;
+    }
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
@@ -3647,7 +3841,34 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const {
+        parsed: baseParsed,
+        malformedAuthorityOrPort: baseMalformed,
+        malformedPercentEncoding: baseMalformedPercentEncoding,
+        malformedSchemeSpecific: baseMalformedSchemeSpecific,
+        malformedHost: baseMalformedHost,
+        malformedScheme: baseMalformedScheme
+      } = parseWithStatus(baseURI, schemelessOptions);
+      const {
+        parsed: relativeParsed,
+        malformedAuthorityOrPort: relativeMalformed,
+        malformedPercentEncoding: relativeMalformedPercentEncoding,
+        malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+        malformedHost: relativeMalformedHost,
+        malformedScheme: relativeMalformedScheme
+      } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+      const resolvedHost = resolved.host;
+      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
+      if (resolved.error && !encodedASCIIHost) {
+        throw new Error(resolved.error);
+      }
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -3707,7 +3928,7 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       const normalizedA = normalizeComparableURI(uriA, options);
       const normalizedB = normalizeComparableURI(uriB, options);
-      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3728,19 +3949,22 @@ var require_fast_uri = __commonJS({
       };
       const options = Object.assign({}, opts);
       const uriTokens = [];
+      if (component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
+      }
       const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+      const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+      const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escapePreservingEscapes(component.path);
-          if (component.scheme !== void 0) {
-            component.path = component.path.split("%3A").join(":");
-          }
+          component.path = serializePathEncoding(component.path, pathNoScheme);
         } else {
           component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
         uriTokens.push(component.scheme, ":");
       }
       const authority = recomposeAuthority(component);
@@ -3758,20 +3982,25 @@ var require_fast_uri = __commonJS({
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
           s = removeDotSegments(s);
         }
+        if (pathNoScheme) {
+          s = serializePathEncoding(s, true);
+        }
         if (authority === void 0 && s[0] === "/" && s[1] === "/") {
           s = "/%2F" + s.slice(2);
         }
         uriTokens.push(s);
       }
       if (component.query !== void 0) {
-        uriTokens.push("?", component.query);
+        uriTokens.push("?", encodeQuery(component.query));
       }
       if (component.fragment !== void 0) {
-        uriTokens.push("#", component.fragment);
+        uriTokens.push("#", encodeFragment(component.fragment));
       }
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+    var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -3781,6 +4010,32 @@ var require_fast_uri = __commonJS({
       }
       return void 0;
     }
+    function hasMalformedPercentEncoding(component) {
+      if (component === void 0) return false;
+      let percent = component.indexOf("%");
+      while (percent !== -1) {
+        if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+          return true;
+        }
+        percent = component.indexOf("%", percent + 3);
+      }
+      return false;
+    }
+    function hasMalformedComponentPercentEncoding(matches) {
+      const host = matches[4];
+      return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !(host[0] === "[" && host[host.length - 1] === "]") && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+    }
+    function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && parsed.host[0] !== "[" && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+        try {
+          parsed.host = new URL("http://" + parsed.host).hostname;
+        } catch (e) {
+          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+          return true;
+        }
+      }
+      return false;
+    }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
@@ -3793,6 +4048,11 @@ var require_fast_uri = __commonJS({
         fragment: void 0
       };
       let malformedAuthorityOrPort = false;
+      let malformedPercentEncoding = false;
+      let malformedSchemeSpecific = false;
+      let malformedHost = false;
+      let malformedIPLiteral = false;
+      let malformedScheme = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3801,6 +4061,25 @@ var require_fast_uri = __commonJS({
           uri = "//" + uri;
         }
       }
+      const authorityMatch = uri.match(AUTHORITY_PREFIX);
+      if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+        parsed.error = "URI authority must not contain a literal backslash.";
+        malformedAuthorityOrPort = true;
+      }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -3810,6 +4089,19 @@ var require_fast_uri = __commonJS({
         parsed.path = matches[6] || "";
         parsed.query = matches[7];
         parsed.fragment = matches[8];
+        if (parsed.scheme !== void 0) {
+          const decodedScheme = unescape(parsed.scheme);
+          if (VALID_SCHEME.test(decodedScheme)) {
+            parsed.scheme = decodedScheme.toLowerCase();
+          } else {
+            parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+            malformedScheme = true;
+          }
+        }
+        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+        if (malformedPercentEncoding) {
+          parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+        }
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
@@ -3821,9 +4113,15 @@ var require_fast_uri = __commonJS({
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
+            const bracketedIPLiteral = parsed.host[0] === "[" && parsed.host[parsed.host.length - 1] === "]";
             const ipv6result = normalizeIPv6(parsed.host);
-            parsed.host = ipv6result.host.toLowerCase();
-            isIP = ipv6result.isIPV6;
+            isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+            malformedIPLiteral = bracketedIPLiteral && ipv6result.error === true;
+            parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+            if (malformedIPLiteral) {
+              parsed.error = parsed.error || "URI host is malformed.";
+              malformedAuthorityOrPort = true;
+            }
           } else {
             isIP = true;
           }
@@ -3841,42 +4139,34 @@ var require_fast_uri = __commonJS({
           parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
         }
         const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-            try {
-              parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
-            } catch (e) {
-              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-            }
-          }
-        }
+        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (uri.indexOf("%") !== -1) {
-            if (parsed.scheme !== void 0) {
-              parsed.scheme = unescape(parsed.scheme);
-            }
-            if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+            if (parsed.host !== void 0 && !malformedIPLiteral) {
+              const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+              parsed.host = reescapeHostDelimiters(host, isIP);
             }
           }
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
+          if (parsed.query) {
+            parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+          }
           if (parsed.fragment) {
-            try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-            } catch {
-              parsed.error = parsed.error || "URI malformed";
-            }
+            parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
           }
         }
         if (schemeHandler && schemeHandler.parse) {
           schemeHandler.parse(parsed, options);
+          if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
+            malformedSchemeSpecific = true;
+          }
         }
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return { parsed, malformedAuthorityOrPort };
+      return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
     function parse3(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
@@ -3885,20 +4175,28 @@ var require_fast_uri = __commonJS({
       return normalizeStringWithStatus(uri, opts).normalized;
     }
     function normalizeStringWithStatus(uri, opts) {
-      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-        malformedAuthorityOrPort
+        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort,
+        malformedPercentEncoding,
+        malformedSchemeSpecific,
+        malformedHost,
+        malformedScheme
       };
     }
     function normalizeComparableURI(uri, opts) {
-      if (typeof uri === "string") {
-        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-        return malformedAuthorityOrPort ? void 0 : normalized;
+      if (typeof uri !== "string" && typeof uri !== "object") {
+        return void 0;
       }
-      if (typeof uri === "object") {
-        return serialize(uri, opts);
+      let value;
+      try {
+        value = typeof uri === "string" ? uri : serialize(uri, opts);
+      } catch {
+        return void 0;
       }
+      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+      return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
     }
     var fastUri = {
       SCHEMES,
@@ -7862,6 +8160,8 @@ var require_defaults2 = __commonJS({
       idleTimeoutMillis: 3e4,
       client_encoding: "",
       ssl: false,
+      // SSL negotiation style: 'postgres' (traditional SSLRequest) or 'direct'
+      sslnegotiation: void 0,
       application_name: void 0,
       fallback_application_name: void 0,
       options: void 0,
@@ -7896,8 +8196,7 @@ var require_utils2 = __commonJS({
   "node_modules/pg/lib/utils.js"(exports, module) {
     "use strict";
     var defaults2 = require_defaults2();
-    var util2 = __require("util");
-    var { isDate } = util2.types || util2;
+    var { isDate } = __require("util/types");
     function escapeElement(elementRepresentation) {
       const escaped = elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
       return '"' + escaped + '"';
@@ -7906,28 +8205,23 @@ var require_utils2 = __commonJS({
       let result = "{";
       for (let i = 0; i < val.length; i++) {
         if (i > 0) {
-          result = result + ",";
-        }
-        if (val[i] === null || typeof val[i] === "undefined") {
-          result = result + "NULL";
-        } else if (Array.isArray(val[i])) {
-          result = result + arrayString(val[i]);
-        } else if (ArrayBuffer.isView(val[i])) {
-          let item = val[i];
+          result += ",";
+        }
+        let item = val[i];
+        if (item == null) {
+          result += "NULL";
+        } else if (Array.isArray(item)) {
+          result += arrayString(item);
+        } else if (ArrayBuffer.isView(item)) {
           if (!(item instanceof Buffer)) {
-            const buf = Buffer.from(item.buffer, item.byteOffset, item.byteLength);
-            if (buf.length === item.byteLength) {
-              item = buf;
-            } else {
-              item = buf.slice(item.byteOffset, item.byteOffset + item.byteLength);
-            }
+            item = Buffer.from(item.buffer, item.byteOffset, item.byteLength);
           }
           result += "\\\\x" + item.toString("hex");
         } else {
-          result += escapeElement(prepareValue(val[i]));
+          result += escapeElement(prepareValue(item));
         }
       }
-      result = result + "}";
+      result += "}";
       return result;
     }
     var prepareValue = function(val, seen) {
@@ -7939,11 +8233,7 @@ var require_utils2 = __commonJS({
           return val;
         }
         if (ArrayBuffer.isView(val)) {
-          const buf = Buffer.from(val.buffer, val.byteOffset, val.byteLength);
-          if (buf.length === val.byteLength) {
-            return buf;
-          }
-          return buf.slice(val.byteOffset, val.byteOffset + val.byteLength);
+          return Buffer.from(val.buffer, val.byteOffset, val.byteLength);
         }
         if (isDate(val)) {
           if (defaults2.parseInputDatesAsUTC) {
@@ -8049,47 +8339,9 @@ var require_utils2 = __commonJS({
   }
 });
 
-// node_modules/pg/lib/crypto/utils-legacy.js
-var require_utils_legacy = __commonJS({
-  "node_modules/pg/lib/crypto/utils-legacy.js"(exports, module) {
-    "use strict";
-    var nodeCrypto = __require("crypto");
-    function md5(string4) {
-      return nodeCrypto.createHash("md5").update(string4, "utf-8").digest("hex");
-    }
-    function postgresMd5PasswordHash(user, password, salt) {
-      const inner = md5(password + user);
-      const outer = md5(Buffer.concat([Buffer.from(inner), salt]));
-      return "md5" + outer;
-    }
-    function sha256(text) {
-      return nodeCrypto.createHash("sha256").update(text).digest();
-    }
-    function hashByName(hashName, text) {
-      hashName = hashName.replace(/(\D)-/, "$1");
-      return nodeCrypto.createHash(hashName).update(text).digest();
-    }
-    function hmacSha256(key, msg) {
-      return nodeCrypto.createHmac("sha256", key).update(msg).digest();
-    }
-    async function deriveKey(password, salt, iterations) {
-      return nodeCrypto.pbkdf2Sync(password, salt, iterations, 32, "sha256");
-    }
-    module.exports = {
-      postgresMd5PasswordHash,
-      randomBytes: nodeCrypto.randomBytes,
-      deriveKey,
-      sha256,
-      hashByName,
-      hmacSha256,
-      md5
-    };
-  }
-});
-
-// node_modules/pg/lib/crypto/utils-webcrypto.js
-var require_utils_webcrypto = __commonJS({
-  "node_modules/pg/lib/crypto/utils-webcrypto.js"(exports, module) {
+// node_modules/pg/lib/crypto/utils.js
+var require_utils3 = __commonJS({
+  "node_modules/pg/lib/crypto/utils.js"(exports, module) {
     var nodeCrypto = __require("crypto");
     module.exports = {
       postgresMd5PasswordHash,
@@ -8138,19 +8390,6 @@ var require_utils_webcrypto = __commonJS({
   }
 });
 
-// node_modules/pg/lib/crypto/utils.js
-var require_utils3 = __commonJS({
-  "node_modules/pg/lib/crypto/utils.js"(exports, module) {
-    "use strict";
-    var useLegacyCrypto = parseInt(process.versions && process.versions.node && process.versions.node.split(".")[0]) < 15;
-    if (useLegacyCrypto) {
-      module.exports = require_utils_legacy();
-    } else {
-      module.exports = require_utils_webcrypto();
-    }
-  }
-});
-
 // node_modules/pg/lib/crypto/cert-signatures.js
 var require_cert_signatures = __commonJS({
   "node_modules/pg/lib/crypto/cert-signatures.js"(exports, module) {
@@ -8270,7 +8509,13 @@ var require_sasl = __commonJS({
     "use strict";
     var crypto = require_utils3();
     var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
-    function startSession(mechanisms, stream) {
+    function saslprep(password) {
+      const nonAsciiSpace = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
+      const mappedToNothing = /[\u00AD\u034F\u1806\u180B\u180C\u180D\u200C\u200D\u2060\uFE00-\uFE0F\uFEFF]/g;
+      return password.replace(nonAsciiSpace, " ").replace(mappedToNothing, "").normalize("NFKC");
+    }
+    var DEFAULT_MAX_SCRAM_ITERATIONS = 1e5;
+    function startSession(mechanisms, stream, scramMaxIterations = DEFAULT_MAX_SCRAM_ITERATIONS) {
       const candidates = ["SCRAM-SHA-256"];
       if (stream) candidates.unshift("SCRAM-SHA-256-PLUS");
       const mechanism = candidates.find((candidate) => mechanisms.includes(candidate));
@@ -8286,7 +8531,8 @@ var require_sasl = __commonJS({
         mechanism,
         clientNonce,
         response: gs2Header + ",,n=*,r=" + clientNonce,
-        message: "SASLInitialResponse"
+        message: "SASLInitialResponse",
+        scramMaxIterations
       };
     }
     async function continueSession(session, password, serverData, stream) {
@@ -8308,6 +8554,12 @@ var require_sasl = __commonJS({
       } else if (sv.nonce.length === session.clientNonce.length) {
         throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
       }
+      const scramMaxIterations = typeof session.scramMaxIterations === "number" ? session.scramMaxIterations : DEFAULT_MAX_SCRAM_ITERATIONS;
+      if (scramMaxIterations !== 0 && sv.iteration > scramMaxIterations) {
+        throw new Error(
+          "SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration count " + sv.iteration + " exceeds scramMaxIterations of " + scramMaxIterations
+        );
+      }
       const clientFirstMessageBare = "n=*,r=" + session.clientNonce;
       const serverFirstMessage = "r=" + sv.nonce + ",s=" + sv.salt + ",i=" + sv.iteration;
       let channelBinding = stream ? "eSws" : "biws";
@@ -8322,7 +8574,7 @@ var require_sasl = __commonJS({
       const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce;
       const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof;
       const saltBytes = Buffer.from(sv.salt, "base64");
-      const saltedPassword = await crypto.deriveKey(password, saltBytes, sv.iteration);
+      const saltedPassword = await crypto.deriveKey(saslprep(password), saltBytes, sv.iteration);
       const clientKey = await crypto.hmacSha256(saltedPassword, "Client Key");
       const storedKey = await crypto.sha256(clientKey);
       const clientSignature = await crypto.hmacSha256(storedKey, authMessage);
@@ -8398,7 +8650,11 @@ var require_sasl = __commonJS({
     }
     function parseServerFinalMessage(serverData) {
       const attrPairs = parseAttributePairs(serverData);
+      const error51 = attrPairs.get("e");
       const serverSignature = attrPairs.get("v");
+      if (error51) {
+        throw new Error(`SASL: SCRAM-SERVER-FINAL-MESSAGE: server returned error: "${error51}"`);
+      }
       if (!serverSignature) {
         throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing");
       } else if (!isBase64(serverSignature)) {
@@ -8426,7 +8682,8 @@ var require_sasl = __commonJS({
     module.exports = {
       startSession,
       continueSession,
-      finalizeSession
+      finalizeSession,
+      DEFAULT_MAX_SCRAM_ITERATIONS
     };
   }
 });
@@ -8728,6 +8985,15 @@ var require_connection_parameters = __commonJS({
             enumerable: false
           });
         }
+        this.sslnegotiation = val("sslnegotiation", config2, "PGSSLNEGOTIATION");
+        if (this.sslnegotiation !== void 0 && this.sslnegotiation !== "postgres" && this.sslnegotiation !== "direct") {
+          throw new Error(
+            `Invalid sslnegotiation value: "${this.sslnegotiation}". Valid values are "postgres" and "direct".`
+          );
+        }
+        if (this.sslnegotiation === "direct" && !this.ssl) {
+          throw new Error("sslnegotiation=direct requires SSL to be enabled");
+        }
         this.client_encoding = val("client_encoding", config2);
         this.replication = val("replication", config2);
         this.isDomainSocket = !(this.host || "").indexOf("/");
@@ -8766,6 +9032,7 @@ var require_connection_parameters = __commonJS({
         add(params, ssl, "sslkey");
         add(params, ssl, "sslcert");
         add(params, ssl, "sslrootcert");
+        add(params, this, "sslnegotiation");
         if (this.database) {
           params.push("dbname=" + quoteParamValue(this.database));
         }
@@ -8866,7 +9133,7 @@ var require_result = __commonJS({
         if (this.fields.length) {
           this._parsers = new Array(fieldDescriptions.length);
         }
-        const row = {};
+        const row = /* @__PURE__ */ Object.create(null);
         for (let i = 0; i < fieldDescriptions.length; i++) {
           const desc = fieldDescriptions[i];
           row[desc.name] = null;
@@ -9007,7 +9274,7 @@ var require_query = __commonJS({
         if (typeof this.text !== "string" && typeof this.name !== "string") {
           return new Error("A query must have either text or a name. Supplying neither is unsupported.");
         }
-        const previous = connection.parsedStatements[this.name];
+        const previous = connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name];
         if (this.text && previous && this.text !== previous) {
           return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
         }
@@ -9027,7 +9294,7 @@ var require_query = __commonJS({
         return null;
       }
       hasBeenParsed(connection) {
-        return this.name && connection.parsedStatements[this.name];
+        return this.name && (connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name]);
       }
       handlePortalSuspended(connection) {
         this._getRows(connection, this.rows);
@@ -9051,6 +9318,9 @@ var require_query = __commonJS({
             name: this.name,
             types: this.types
           });
+          if (this.name) {
+            connection.submittedNamedStatements[this.name] = this.text;
+          }
         }
         try {
           connection.bind({
@@ -9061,6 +9331,8 @@ var require_query = __commonJS({
             valueMapper: utils.prepareValue
           });
         } catch (err) {
+          connection.close({ type: "S", name: this.name });
+          connection.sync();
           this.handleError(err, connection);
           return;
         }
@@ -9300,6 +9572,25 @@ var require_buffer_writer = __commonJS({
         this.offset += len;
         return this;
       }
+      // Write an Int32 byte-length prefix immediately followed by the string's UTF-8
+      // bytes. Postgres' Bind wire format prefixes every parameter with its length,
+      // and doing it in one method computes Buffer.byteLength ONCE — the previous
+      // `addInt32(Buffer.byteLength(s)).addString(s)` pairing scanned the string
+      // three times (byteLength for the prefix, byteLength again inside addString,
+      // then the encode), which is costly for large text parameters.
+      addInt32PrefixedString(string4) {
+        const len = Buffer.byteLength(string4);
+        this.ensure(4 + len);
+        const buffer = this.buffer;
+        let offset = this.offset;
+        buffer[offset++] = len >>> 24 & 255;
+        buffer[offset++] = len >>> 16 & 255;
+        buffer[offset++] = len >>> 8 & 255;
+        buffer[offset++] = len >>> 0 & 255;
+        buffer.write(string4, offset, "utf-8");
+        this.offset = offset + len;
+        return this;
+      }
       add(otherBuffer) {
         this.ensure(otherBuffer.length);
         otherBuffer.copy(this.buffer, this.offset);
@@ -9321,6 +9612,10 @@ var require_buffer_writer = __commonJS({
         this.buffer = Buffer.allocUnsafe(this.size);
         return result;
       }
+      clear() {
+        this.offset = 5;
+        this.headerPosition = 0;
+      }
     };
     exports.Writer = Writer;
   }
@@ -9357,7 +9652,7 @@ var require_serializer = __commonJS({
       );
     };
     var sendSASLInitialResponseMessage = function(mechanism, initialResponse) {
-      writer.addCString(mechanism).addInt32(Buffer.byteLength(initialResponse)).addString(initialResponse);
+      writer.addCString(mechanism).addInt32PrefixedString(initialResponse);
       return writer.flush(
         112
         /* code.startup */
@@ -9416,8 +9711,7 @@ var require_serializer = __commonJS({
             0
             /* ParamType.STRING */
           );
-          paramWriter.addInt32(Buffer.byteLength(mappedVal));
-          paramWriter.addString(mappedVal);
+          paramWriter.addInt32PrefixedString(mappedVal);
         }
       }
     };
@@ -9429,7 +9723,13 @@ var require_serializer = __commonJS({
       const len = values.length;
       writer.addCString(portal).addCString(statement);
       writer.addInt16(len);
-      writeValues(values, config2.valueMapper);
+      try {
+        writeValues(values, config2.valueMapper);
+      } catch (err) {
+        writer.clear();
+        paramWriter.clear();
+        throw err;
+      }
       writer.addInt16(len);
       writer.add(paramWriter.flush());
       writer.addInt16(1);
@@ -9587,7 +9887,7 @@ var require_buffer_reader = __commonJS({
       cstring() {
         const start = this.offset;
         let end = start;
-        while (this.buffer[end++] !== 0) {
+        while (this.buffer[end++]) {
         }
         this.offset = end;
         return this.buffer.toString(this.encoding, start, end - 1);
@@ -9809,7 +10109,7 @@ var require_parser = __commonJS({
       const parameterCount = reader.int16();
       const message = new messages_1.ParameterDescriptionMessage(LATEINIT_LENGTH, parameterCount);
       for (let i = 0; i < parameterCount; i++) {
-        message.dataTypeIDs[i] = reader.int32();
+        message.dataTypeIDs[i] = reader.uint32();
       }
       return message;
     };
@@ -9914,7 +10214,8 @@ var require_dist2 = __commonJS({
   "node_modules/pg-protocol/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.DatabaseError = exports.serialize = exports.parse = void 0;
+    exports.DatabaseError = exports.serialize = void 0;
+    exports.parse = parse3;
     var messages_1 = require_messages();
     Object.defineProperty(exports, "DatabaseError", { enumerable: true, get: function() {
       return messages_1.DatabaseError;
@@ -9929,7 +10230,6 @@ var require_dist2 = __commonJS({
       stream.on("data", (buffer) => parser.parse(buffer, callback));
       return new Promise((resolve) => stream.on("end", () => resolve()));
     }
-    exports.parse = parse3;
   }
 });
 
@@ -10014,7 +10314,8 @@ var require_connection = __commonJS({
     "use strict";
     var EventEmitter = __require("events").EventEmitter;
     var { parse: parse3, serialize } = require_dist2();
-    var { getStream, getSecureStream } = require_stream();
+    var stream = require_stream();
+    var { getStream } = stream;
     var flushBuffer = serialize.flush();
     var syncBuffer = serialize.sync();
     var endBuffer = serialize.end();
@@ -10029,7 +10330,9 @@ var require_connection = __commonJS({
         this._keepAlive = config2.keepAlive;
         this._keepAliveInitialDelayMillis = config2.keepAliveInitialDelayMillis;
         this.parsedStatements = {};
+        this.submittedNamedStatements = {};
         this.ssl = config2.ssl || false;
+        this.sslNegotiation = config2.sslNegotiation || "postgres";
         this._ending = false;
         this._emitMessage = false;
         const self = this;
@@ -10063,6 +10366,11 @@ var require_connection = __commonJS({
         if (!this.ssl) {
           return this.attachListeners(this.stream);
         }
+        if (this.sslNegotiation === "direct") {
+          return this.stream.once("connect", function() {
+            self.upgradeToSSL(host, reportStreamError);
+          });
+        }
         this.stream.once("data", function(buffer) {
           const responseCode = buffer.toString("utf8");
           switch (responseCode) {
@@ -10075,31 +10383,38 @@ var require_connection = __commonJS({
               self.stream.end();
               return self.emit("error", new Error("There was an error establishing an SSL connection"));
           }
-          const options = {
-            socket: self.stream
-          };
-          if (self.ssl !== true) {
-            Object.assign(options, self.ssl);
-            if ("key" in self.ssl) {
-              options.key = self.ssl.key;
-            }
-          }
-          const net = __require("net");
-          if (net.isIP && net.isIP(host) === 0) {
-            options.servername = host;
-          }
-          try {
-            self.stream = getSecureStream(options);
-          } catch (err) {
-            return self.emit("error", err);
-          }
-          self.attachListeners(self.stream);
-          self.stream.on("error", reportStreamError);
-          self.emit("sslconnect");
+          self.upgradeToSSL(host, reportStreamError);
         });
       }
-      attachListeners(stream) {
-        parse3(stream, (msg) => {
+      upgradeToSSL(host, reportStreamError) {
+        const self = this;
+        const options = {
+          socket: self.stream
+        };
+        if (self.ssl !== true) {
+          Object.assign(options, self.ssl);
+          if ("key" in self.ssl) {
+            options.key = self.ssl.key;
+          }
+        }
+        if (self.sslNegotiation === "direct") {
+          options.ALPNProtocols = ["postgresql"];
+        }
+        const net = __require("net");
+        if (net.isIP && net.isIP(host) === 0) {
+          options.servername = host;
+        }
+        try {
+          self.stream = stream.getSecureStream(options);
+        } catch (err) {
+          return self.emit("error", err);
+        }
+        self.attachListeners(self.stream);
+        self.stream.on("error", reportStreamError);
+        self.emit("sslconnect");
+      }
+      attachListeners(stream2) {
+        parse3(stream2, (msg) => {
           const eventName = msg.name === "error" ? "errorMessage" : msg.name;
           if (this._emitMessage) {
             this.emit("message", msg);
@@ -10522,6 +10837,16 @@ var require_client = __commonJS({
       },
       "Calling client.query() when the client is already executing a query is deprecated and will be removed in pg@9.0. Use async/await or an external async flow control mechanism instead."
     );
+    function coerceNumberOrDefault(value, defaultValue) {
+      if (typeof value === "number") {
+        return Number.isFinite(value) ? value : defaultValue;
+      }
+      if (typeof value === "string" && value.trim() !== "") {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : defaultValue;
+      }
+      return defaultValue;
+    }
     var Client2 = class extends EventEmitter {
       constructor(config2) {
         super();
@@ -10550,19 +10875,25 @@ var require_client = __commonJS({
         this._connectionError = false;
         this._queryable = true;
         this._activeQuery = null;
+        this._txStatus = null;
         this.enableChannelBinding = Boolean(c.enableChannelBinding);
+        this.scramMaxIterations = coerceNumberOrDefault(c.scramMaxIterations, sasl.DEFAULT_MAX_SCRAM_ITERATIONS);
         this.connection = c.connection || new Connection2({
           stream: c.stream,
           ssl: this.connectionParameters.ssl,
+          sslNegotiation: this.connectionParameters.sslnegotiation,
           keepAlive: c.keepAlive || false,
           keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
           encoding: this.connectionParameters.client_encoding || "utf8"
         });
         this._queryQueue = [];
+        this._sentQueryQueue = [];
+        this.pipeline = Boolean(c.pipeline);
         this.binary = c.binary || defaults2.binary;
         this.processID = null;
         this.secretKey = null;
         this.ssl = this.connectionParameters.ssl || false;
+        this.sslNegotiation = this.connectionParameters.sslnegotiation || "postgres";
         if (this.ssl && this.ssl.key) {
           Object.defineProperty(this.ssl, "key", {
             enumerable: false
@@ -10592,6 +10923,8 @@ var require_client = __commonJS({
           enqueueError(activeQuery);
           this._activeQuery = null;
         }
+        this._sentQueryQueue.forEach(enqueueError);
+        this._sentQueryQueue.length = 0;
         this._queryQueue.forEach(enqueueError);
         this._queryQueue.length = 0;
       }
@@ -10623,7 +10956,9 @@ var require_client = __commonJS({
         }
         con.on("connect", function() {
           if (self.ssl) {
-            con.requestSsl();
+            if (self.sslNegotiation !== "direct") {
+              con.requestSsl();
+            }
           } else {
             con.startup(self.getStartupConf());
           }
@@ -10741,7 +11076,11 @@ var require_client = __commonJS({
       _handleAuthSASL(msg) {
         this._getPassword(() => {
           try {
-            this.saslSession = sasl.startSession(msg.mechanisms, this.enableChannelBinding && this.connection.stream);
+            this.saslSession = sasl.startSession(
+              msg.mechanisms,
+              this.enableChannelBinding && this.connection.stream,
+              this.scramMaxIterations
+            );
             this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response);
           } catch (err) {
             this.connection.emit("error", err);
@@ -10786,6 +11125,7 @@ var require_client = __commonJS({
         }
         const activeQuery = this._getActiveQuery();
         this._activeQuery = null;
+        this._txStatus = msg?.status ?? null;
         this.readyForQuery = true;
         if (activeQuery) {
           activeQuery.handleReadyForQuery(this.connection);
@@ -10827,6 +11167,9 @@ var require_client = __commonJS({
           return;
         }
         this._activeQuery = null;
+        if (activeQuery.name) {
+          delete this.connection.submittedNamedStatements[activeQuery.name];
+        }
         activeQuery.handleError(msg, this.connection);
       }
       _handleRowDescription(msg) {
@@ -10883,6 +11226,7 @@ var require_client = __commonJS({
         }
         if (activeQuery.name) {
           this.connection.parsedStatements[activeQuery.name] = activeQuery.text;
+          delete this.connection.submittedNamedStatements[activeQuery.name];
         }
       }
       _handleCopyInResponse(msg) {
@@ -10949,6 +11293,9 @@ var require_client = __commonJS({
           });
         } else if (client._queryQueue.indexOf(query) !== -1) {
           client._queryQueue.splice(client._queryQueue.indexOf(query), 1);
+        } else if (client._sentQueryQueue.indexOf(query) !== -1) {
+          query.callback = () => {
+          };
         }
       }
       setTypeParser(oid, format, parseFn) {
@@ -10967,6 +11314,10 @@ var require_client = __commonJS({
         return utils.escapeLiteral(str);
       }
       _pulseQueryQueue() {
+        if (this.pipeline) {
+          this._pulsePipelinedQueryQueue();
+          return;
+        }
         if (this.readyForQuery === true) {
           this._activeQuery = this._queryQueue.shift();
           const activeQuery = this._getActiveQuery();
@@ -10987,16 +11338,37 @@ var require_client = __commonJS({
           }
         }
       }
+      _pulsePipelinedQueryQueue() {
+        if (!this._connected || !this._queryable) {
+          return;
+        }
+        while (this._queryQueue.length > 0) {
+          const query = this._queryQueue.shift();
+          this.hasExecuted = true;
+          const queryError = query.submit(this.connection);
+          if (queryError) {
+            process.nextTick(() => {
+              query.handleError(queryError, this.connection);
+            });
+            continue;
+          }
+          this._sentQueryQueue.push(query);
+        }
+        if (this.readyForQuery && !this._activeQuery && this._sentQueryQueue.length > 0) {
+          this._activeQuery = this._sentQueryQueue.shift();
+          this.readyForQuery = false;
+        }
+        if (!this._activeQuery && this._sentQueryQueue.length === 0 && this._queryQueue.length === 0 && this.hasExecuted) {
+          this.emit("drain");
+        }
+      }
       query(config2, values, callback) {
         let query;
         let result;
-        let readTimeout;
-        let readTimeoutTimer;
-        let queryCallback;
-        if (config2 === null || config2 === void 0) {
+        if (config2 == null) {
           throw new TypeError("Client was passed a null or undefined query");
-        } else if (typeof config2.submit === "function") {
-          readTimeout = config2.query_timeout || this.connectionParameters.query_timeout;
+        }
+        if (typeof config2.submit === "function") {
           result = query = config2;
           if (!query.callback) {
             if (typeof values === "function") {
@@ -11006,7 +11378,6 @@ var require_client = __commonJS({
             }
           }
         } else {
-          readTimeout = config2.query_timeout || this.connectionParameters.query_timeout;
           query = new Query2(config2, values, callback);
           if (!query.callback) {
             result = new this._Promise((resolve, reject) => {
@@ -11015,12 +11386,15 @@ var require_client = __commonJS({
               Error.captureStackTrace(err);
               throw err;
             });
+          } else if (typeof query.callback !== "function") {
+            throw new TypeError("callback is not a function");
           }
         }
+        const readTimeout = config2.query_timeout || this.connectionParameters.query_timeout;
         if (readTimeout) {
-          queryCallback = query.callback || (() => {
+          const queryCallback = query.callback || (() => {
           });
-          readTimeoutTimer = setTimeout(() => {
+          const readTimeoutTimer = setTimeout(() => {
             const error51 = new Error("Query read timeout");
             process.nextTick(() => {
               query.handleError(error51, this.connection);
@@ -11031,6 +11405,9 @@ var require_client = __commonJS({
             const index = this._queryQueue.indexOf(query);
             if (index > -1) {
               this._queryQueue.splice(index, 1);
+            } else if (this.pipeline) {
+              this.connection.stream.destroy();
+              return;
             }
             this._pulseQueryQueue();
           }, readTimeout);
@@ -11057,7 +11434,7 @@ var require_client = __commonJS({
           });
           return result;
         }
-        if (this._queryQueue.length > 0) {
+        if (this._queryQueue.length > 0 && !this.pipeline) {
           queryQueueLengthDeprecationNotice();
         }
         this._queryQueue.push(query);
@@ -11070,16 +11447,24 @@ var require_client = __commonJS({
       unref() {
         this.connection.unref();
       }
+      getTransactionStatus() {
+        return this._txStatus;
+      }
       end(cb) {
         this._ending = true;
         if (!this.connection._connecting || this._ended) {
           if (cb) {
             cb();
+            return;
           } else {
             return this._Promise.resolve();
           }
         }
-        if (this._getActiveQuery() || !this._queryable) {
+        if (!this._queryable) {
+          this.connection.stream.destroy();
+        } else if (this.pipeline && (this._getActiveQuery() || this._sentQueryQueue.length > 0 || this._queryQueue.length > 0)) {
+          this.once("drain", () => this.connection.end());
+        } else if (this._getActiveQuery()) {
           this.connection.stream.destroy();
         } else {
           this.connection.end();
@@ -11569,7 +11954,7 @@ var require_query2 = __commonJS({
       sourceFunction: "routine"
     };
     NativeQuery.prototype.handleError = function(err) {
-      const fields = this.native.pq.resultErrorFields();
+      const fields = this.native && this.native.pq.resultErrorFields();
       if (fields) {
         for (const key in fields) {
           const normalizedFieldName = errorFieldMap[key] || key;
@@ -11702,6 +12087,8 @@ var require_client2 = __commonJS({
       this._connecting = false;
       this._connected = false;
       this._queryable = true;
+      this.pipeline = Boolean(config2.pipeline);
+      this._pipelineInFlight = false;
       const cp = this.connectionParameters = new ConnectionParameters(config2);
       if (config2.nativeConnectionString) cp.nativeConnectionString = config2.nativeConnectionString;
       this.user = cp.user;
@@ -11845,7 +12232,7 @@ var require_client2 = __commonJS({
         });
         return result;
       }
-      if (this._queryQueue.length > 0) {
+      if (this._queryQueue.length > 0 && !this.pipeline) {
         queryQueueLengthDeprecationNotice();
       }
       this._queryQueue.push(query);
@@ -11855,8 +12242,11 @@ var require_client2 = __commonJS({
     Client2.prototype.end = function(cb) {
       const self = this;
       this._ending = true;
-      if (!this._connected) {
-        this.once("connect", this.end.bind(this, cb));
+      if (this._connecting && !this._connected) {
+        this.once("connect", () => {
+          this.end(() => {
+          });
+        });
       }
       let result;
       if (!cb) {
@@ -11864,14 +12254,21 @@ var require_client2 = __commonJS({
           cb = (err) => err ? reject(err) : resolve();
         });
       }
-      this.native.end(function() {
-        self._connected = false;
-        self._errorAllQueries(new Error("Connection terminated"));
-        process.nextTick(() => {
-          self.emit("end");
-          if (cb) cb();
+      const doEnd = function() {
+        self.native.end(function() {
+          self._connected = false;
+          self._errorAllQueries(new Error("Connection terminated"));
+          process.nextTick(() => {
+            self.emit("end");
+            if (cb) cb();
+          });
         });
-      });
+      };
+      if (this.pipeline && (this._pipelineInFlight || this._queryQueue.length > 0)) {
+        this.once("drain", doEnd);
+      } else {
+        doEnd();
+      }
       return result;
     };
     Client2.prototype._hasActiveQuery = function() {
@@ -11881,6 +12278,9 @@ var require_client2 = __commonJS({
       if (!this._connected) {
         return;
       }
+      if (this.pipeline && !initialConnection) {
+        return this._pulsePipelinedQueryQueue();
+      }
       if (this._hasActiveQuery()) {
         return;
       }
@@ -11898,6 +12298,69 @@ var require_client2 = __commonJS({
         self._pulseQueryQueue();
       });
     };
+    Client2.prototype._pulsePipelinedQueryQueue = function() {
+      if (!this._connected || this._pipelineInFlight) {
+        return;
+      }
+      if (this._queryQueue.length === 0) {
+        if (this.hasExecuted) {
+          this.emit("drain");
+        }
+        return;
+      }
+      this._pipelineInFlight = true;
+      const self = this;
+      const queries = [];
+      const nativeQueries = [];
+      const utils = require_utils2();
+      while (this._queryQueue.length > 0) {
+        const query = this._queryQueue.shift();
+        this.hasExecuted = true;
+        nativeQueries.push(query);
+        const values = query.values ? query.values.map(utils.prepareValue) : null;
+        const pipelineEntry = { text: query.text, name: query.name };
+        if (values) {
+          pipelineEntry.values = values;
+        }
+        if (query.name && this.namedQueries[query.name]) {
+          pipelineEntry._alreadyPrepared = true;
+        }
+        queries.push(pipelineEntry);
+      }
+      this.native.pipeline(queries, function(err, results) {
+        self._pipelineInFlight = false;
+        if (err) {
+          for (let i = 0; i < nativeQueries.length; i++) {
+            const q = nativeQueries[i];
+            q.native = self.native;
+            q.handleError(err);
+          }
+          self._pulsePipelinedQueryQueue();
+          return;
+        }
+        for (let i = 0; i < nativeQueries.length; i++) {
+          const q = nativeQueries[i];
+          const r = results[i];
+          q.native = self.native;
+          if (r.err) {
+            q.handleError(r.err);
+          } else {
+            if (q.name) {
+              self.namedQueries[q.name] = q.text;
+            }
+            q.state = "end";
+            q.emit("end", r.result);
+            if (q.callback) {
+              q.callback(null, r.result);
+            }
+          }
+          setImmediate(function() {
+            q.emit("_done");
+          });
+        }
+        self._pulsePipelinedQueryQueue();
+      });
+    };
     Client2.prototype.cancel = function(query) {
       if (this._activeQuery === query) {
         this.native.cancel(function() {
@@ -11919,6 +12382,9 @@ var require_client2 = __commonJS({
     Client2.prototype.isConnected = function() {
       return this._connected;
     };
+    Client2.prototype.getTransactionStatus = function() {
+      return this.native.getTransactionStatus();
+    };
   }
 });
 
@@ -28152,17 +28618,33 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
+function getDotPath(path) {
+  if (path.length === 0) {
+    return "object root";
+  }
+  return path.reduce((acc, seg, index) => {
+    if (index === 0) {
+      return String(seg);
+    }
+    if (typeof seg === "number") {
+      return `${acc}[${seg}]`;
+    }
+    return `${acc}.${seg}`;
+  }, "");
+}
 function getParseErrorMessage(error51) {
   if (error51 && typeof error51 === "object") {
+    if ("issues" in error51 && Array.isArray(error51.issues) && error51.issues.length > 0) {
+      return error51.issues.map((i) => {
+        if (!i.path?.length) {
+          return i.message;
+        }
+        return `${i.message} at ${getDotPath(i.path)}`;
+      }).join("\n");
+    }
     if ("message" in error51 && typeof error51.message === "string") {
       return error51.message;
     }
-    if ("issues" in error51 && Array.isArray(error51.issues) && error51.issues.length > 0) {
-      const firstIssue = error51.issues[0];
-      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
-        return String(firstIssue.message);
-      }
-    }
     try {
       return JSON.stringify(error51);
     } catch {
@@ -34777,16 +35259,7 @@ var Server = class extends Protocol {
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
-    let methodValue;
-    if (isZ4Schema(methodSchema)) {
-      const v4Schema = methodSchema;
-      const v4Def = v4Schema._zod?.def;
-      methodValue = v4Def?.value ?? v4Schema.value;
-    } else {
-      const v3Schema = methodSchema;
-      const legacyDef = v3Schema._def;
-      methodValue = legacyDef?.value ?? v3Schema.value;
-    }
+    const methodValue = getLiteralValue(methodSchema);
     if (typeof methodValue !== "string") {
       throw new Error("Schema method literal must be a string");
     }
@@ -35974,8 +36447,17 @@ var EMPTY_COMPLETION_RESULT = {
 import process3 from "node:process";
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 var ReadBuffer = class {
+  constructor(options) {
+    this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+  }
   append(chunk) {
+    const newSize = (this._buffer?.length ?? 0) + chunk.length;
+    if (newSize > this._maxBufferSize) {
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+    }
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
   }
   readMessage() {
@@ -36003,18 +36485,24 @@ function serializeMessage(message) {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var StdioServerTransport = class {
-  constructor(_stdin = process3.stdin, _stdout = process3.stdout) {
+  constructor(_stdin = process3.stdin, _stdout = process3.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
-    this._readBuffer = new ReadBuffer();
     this._started = false;
     this._ondata = (chunk) => {
-      this._readBuffer.append(chunk);
-      this.processReadBuffer();
+      try {
+        this._readBuffer.append(chunk);
+        this.processReadBuffer();
+      } catch (error51) {
+        this.onerror?.(error51);
+        this.close().catch(() => {
+        });
+      }
     };
     this._onerror = (error51) => {
       this.onerror?.(error51);
     };
+    this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
   }
   /**
    * Starts listening for messages on stdin.
@@ -36115,6 +36603,31 @@ function isWritesAllowed() {
   const v = process.env.ALLOW_WRITES;
   return v === "1" || v === "true";
 }
+function getApplicationName() {
+  const raw = process.env.POSTGRES_APPLICATION_NAME;
+  return raw && raw.trim() !== "" ? raw : "postgres-mcp";
+}
+var PG16 = 16e4;
+var PG17 = 17e4;
+var PG18 = 18e4;
+var serverVersionNum = null;
+var poolGeneration = 0;
+async function getServerVersionNum(client) {
+  if (serverVersionNum !== null) return serverVersionNum;
+  const generation = poolGeneration;
+  try {
+    const runner = client ?? getPool();
+    const res = await runner.query("SELECT current_setting('server_version_num') AS v");
+    const parsed = Number.parseInt(res.rows[0]?.v ?? "", 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      if (generation === poolGeneration) serverVersionNum = parsed;
+      return parsed;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
 function getSslConfig() {
   const raw = process.env.POSTGRES_SSL_REJECT_UNAUTHORIZED;
   if (raw === void 0) return void 0;
@@ -36130,6 +36643,11 @@ function getPool() {
   const ssl = getSslConfig();
   pool = new esm_default.Pool({
     connectionString: getDatabaseUrl(),
+    // Identify this server in pg_stat_activity. Without it, agent traffic is
+    // anonymous to whoever is watching the database -- while pg_health itself
+    // reports application_name for every OTHER session. See getApplicationName
+    // for why a DSN-supplied application_name still wins.
+    application_name: getApplicationName(),
     statement_timeout: getStatementTimeoutMs(),
     connectionTimeoutMillis: getConnectionTimeoutMs(),
     max: getPoolMax(),
@@ -36355,6 +36873,8 @@ async function withSharedClient(fn) {
 }
 async function shutdown() {
   typeNameCache = null;
+  serverVersionNum = null;
+  poolGeneration++;
   if (!pool) return;
   const ending = pool;
   pool = null;
@@ -36709,7 +37229,7 @@ var adminTools = [
   },
   {
     name: "pg_advisor",
-    description: "Rolled-up DBA lint pass. One call returns three categories of findings:\n- sequence_exhaustion: SERIAL / BIGSERIAL / IDENTITY sequences whose `last_value` is above `seqExhaustionThreshold` of `max_value`. The classic incident class.\n- tables_without_primary_key: user tables (plain and partitioned) with no PK defined. Bloat candidates and a sign of design drift; some replication setups also need PKs. Foreign tables are excluded -- PostgreSQL forbids declaring PKs on foreign tables.\n- public_tables_without_rls: tables in `public` (or any schema in `rlsSchemas`) with row-level security disabled. Useful as a security baseline check.\nUse this as the 'what should I be looking at?' starting point, then drill into `pg_unused_indexes`, `pg_table_bloat`, `pg_seq_scan_tables` for the perf side.",
+    description: "Rolled-up DBA lint pass. One call returns four categories of findings:\n- sequence_exhaustion: SERIAL / BIGSERIAL / IDENTITY sequences whose `last_value` is above `seqExhaustionThreshold` of `max_value`. The classic incident class.\n- wraparound_risk: transaction-ID AND multixact wraparound pressure, the classic pageable incident. `{autovacuum_freeze_max_age, autovacuum_multixact_freeze_max_age, databases[], tables[]}`. Those two cluster GUCs are the divisors both lists are measured against (null if unreadable). Multixact IDs are a SEPARATE 32-bit counter, consumed by row-level locking (`SELECT ... FOR SHARE/UPDATE`, FK checks), so a lock-heavy workload can exhaust them while relfrozenxid stays perfectly healthy -- both counters are checked here. `databases` rows: `{database, xid_age (age(datfrozenxid)), mxid_age (mxid_age(datminmxid)), pct_of_freeze_max_age, pct_of_multixact_freeze_max_age, triggered_by}` -- template databases included, since template0 ages like any other and the cluster horizon is the minimum across all of them. `tables` rows: `{schema, table, relkind, xid_age (age(relfrozenxid)), freeze_max_age, pct_of_freeze_max_age, mxid_age (mxid_age(relminmxid)), multixact_freeze_max_age, pct_of_multixact_freeze_max_age, triggered_by}`, where `freeze_max_age` / `multixact_freeze_max_age` are the EFFECTIVE limits -- a per-table `autovacuum_freeze_max_age` / `autovacuum_multixact_freeze_max_age` storage parameter wins over the GUC. A row is returned when EITHER ratio is at or above `wraparoundThreshold`, and `triggered_by` ('xid' | 'multixact' | 'both') says which one did it: 'xid' means chase freezing/autovacuum, 'multixact' means chase the lock-heavy workload burning members. `mxid_age` and `pct_of_multixact_freeze_max_age` are null on rows whose minmxid is InvalidMultiXactId (no multixact ever recorded); such rows can only be xid-triggered. At pct_of_freeze_max_age 1.0 autovacuum forces an anti-wraparound VACUUM, and near 2.1 billion xids (or 4.2 billion multixacts) the server stops accepting writes. `tables` deliberately includes pg_catalog and pg_toast relations -- the culprit is more often a TOAST table or a system catalog than a user table. On PG18+ table rows also carry `pages` / `all_frozen_pages` / `frozen_page_fraction` from `pg_class.relallfrozen` (visibility-map freeze coverage); those three keys are ABSENT on older servers rather than null.\n- tables_without_primary_key: user tables (plain and partitioned) with no PK defined. Bloat candidates and a sign of design drift; some replication setups also need PKs. Foreign tables are excluded -- PostgreSQL forbids declaring PKs on foreign tables.\n- public_tables_without_rls: tables in `public` (or any schema in `rlsSchemas`) with row-level security disabled. Useful as a security baseline check.\nAny category whose query fails (permission-gated catalogs on managed providers) appends to `_warnings` and returns empty; the other categories still return.\nUse this as the 'what should I be looking at?' starting point, then drill into `pg_unused_indexes`, `pg_table_bloat`, `pg_seq_scan_tables` for the perf side.",
     annotations: {
       title: "Database advisor (DBA lints)",
       readOnlyHint: true,
@@ -36719,17 +37239,26 @@ var adminTools = [
     },
     inputSchema: external_exports.object({
       seqExhaustionThreshold: external_exports.number().min(0).max(1).default(0.5).describe("Minimum used-fraction (last_value / max_value) to flag a sequence (default 0.5 = 50%)."),
+      wraparoundThreshold: external_exports.number().min(0).max(1).default(0.5).describe(
+        "Minimum used-fraction to flag a database or table for wraparound risk (default 0.5 = 50%). Applied to BOTH ratios -- age(frozenxid) / autovacuum_freeze_max_age and mxid_age(minmxid) / autovacuum_multixact_freeze_max_age -- and a row is flagged if either one clears it. 1.0 is where autovacuum starts forcing anti-wraparound VACUUMs."
+      ),
       rlsSchemas: external_exports.array(identSchema).default(["public"]).describe("Schemas where RLS-missing should be flagged. Defaults to ['public']."),
       limit: external_exports.number().int().min(1).max(500).default(50).describe("Max rows per category (default 50).")
     }),
     handler: async (input) => {
       const {
         seqExhaustionThreshold = 0.5,
+        wraparoundThreshold = 0.5,
         rlsSchemas = ["public"],
         limit = 50
       } = input;
+      const versionNum = await getServerVersionNum();
+      const frozenCoverageCols = versionNum >= PG18 ? `,
+               c.relpages AS pages,
+               c.relallfrozen AS all_frozen_pages,
+               (c.relallfrozen::numeric / NULLIF(c.relpages, 0))::numeric(6, 4)::float8 AS frozen_page_fraction` : "";
       return withSharedClient(async (run) => {
-        const [seqRes, noPkRes, rlsRes] = await Promise.all([
+        const [seqRes, wrapGucRes, wrapDbRes, wrapTblRes, noPkRes, rlsRes] = await Promise.all([
           run(
             // pg_sequences was added in PG10. last_value can be NULL on a never-
             // touched sequence; we filter those out (nothing to report yet).
@@ -36755,6 +37284,193 @@ var adminTools = [
              LIMIT $2`,
             [seqExhaustionThreshold, limit]
           ),
+          run(
+            // Fetched as its own row rather than repeated on every finding:
+            // both wraparound lists are threshold-filtered, so on a healthy
+            // cluster they are empty and a per-row copy of the GUC would leave
+            // the category with no scale at all. The caller needs the divisor
+            // to interpret an empty result as "nothing above the threshold"
+            // rather than "could not measure".
+            //
+            // Both GUCs come back in ONE row, not two sub-queries: they are
+            // the two divisors for the same category, and splitting them would
+            // add a seventh round trip to the fanout for a second scalar that
+            // fails or succeeds under exactly the same conditions as the first.
+            // autovacuum_multixact_freeze_max_age exists as far back as PG9.3,
+            // so unlike relallfrozen below it needs no version gate.
+            `SELECT
+               current_setting('autovacuum_freeze_max_age')::int AS autovacuum_freeze_max_age,
+               current_setting('autovacuum_multixact_freeze_max_age')::int AS autovacuum_multixact_freeze_max_age`
+          ),
+          run(
+            // Template databases are deliberately NOT excluded. template0 has
+            // datallowconn = false and so is never autovacuumed through the
+            // normal path, but its datfrozenxid ages exactly like any other
+            // database and the cluster-wide wraparound horizon is the MINIMUM
+            // across all of pg_database. Filtering templates out is how a
+            // wraparound incident hides from the check that was meant to catch
+            // it.
+            //
+            // numeric(10, 4), not the numeric(6, 4) used for sequence
+            // exhaustion: that ratio is bounded by 1 (a sequence cannot pass
+            // its max_value), this one is not. age() tops out near 2.1e9 and
+            // autovacuum_freeze_max_age can legally be set as low as 1e5, so a
+            // ratio of ~21000 is reachable and would overflow a 6-digit
+            // numeric -- turning a wraparound alarm into a numeric field
+            // overflow error at the exact moment it matters. The multixact
+            // ratio fits the same width: mxid_age tops out near 4.3e9 and the
+            // GUC's floor is 10000, so ~430000 is the worst case.
+            //
+            // datminmxid is tracked SEPARATELY from datfrozenxid, and a
+            // database can hit autovacuum_multixact_freeze_max_age with a
+            // perfectly healthy relfrozenxid -- multixacts are burned by
+            // row-level locking (SELECT ... FOR SHARE/UPDATE, FK checks), not
+            // by transaction volume. Checking only the xid side reports a
+            // lock-heavy cluster as clean right up to the multixact shutdown.
+            //
+            // The InvalidMultiXactId guard is `<> '0'::xid` because
+            // pg_database.datminmxid is catalog-typed `xid` even though it
+            // holds a MultiXactId -- there is no `mxid` type to cast to, and
+            // mxid_age('0'::xid) would report a ~4.2-billion age for a
+            // database that has simply never recorded a multixact. It yields
+            // NULL rather than dropping the row: a NULL ratio can never
+            // satisfy `>= $1`, so the row is still returned (and correctly
+            // labelled 'xid') when its xid age is what is dangerous.
+            //
+            // ORDER BY is the GREATER of the two ratios, not age(datfrozenxid):
+            // with the filter now an OR, ordering by the xid age alone would
+            // sort a multixact-critical database near the bottom and let LIMIT
+            // cut the only row that mattered. triggered_by is computed from
+            // the same full-precision ratios the WHERE uses (not the rounded
+            // pct_* columns), so the label can never disagree with the reason
+            // the row came back.
+            `SELECT
+               d.datname AS database,
+               age(d.datfrozenxid) AS xid_age,
+               mx.mxid_age AS mxid_age,
+               r.xid_ratio::numeric(10, 4)::float8 AS pct_of_freeze_max_age,
+               r.mxid_ratio::numeric(10, 4)::float8 AS pct_of_multixact_freeze_max_age,
+               CASE
+                 WHEN r.xid_ratio >= $1 AND r.mxid_ratio >= $1 THEN 'both'
+                 WHEN r.mxid_ratio >= $1 THEN 'multixact'
+                 ELSE 'xid'
+               END AS triggered_by
+             FROM pg_catalog.pg_database d
+             CROSS JOIN LATERAL (
+               SELECT CASE WHEN d.datminmxid <> '0'::xid THEN mxid_age(d.datminmxid) END AS mxid_age
+             ) mx
+             CROSS JOIN LATERAL (
+               SELECT
+                 (age(d.datfrozenxid)::numeric
+                    / NULLIF(current_setting('autovacuum_freeze_max_age')::numeric, 0)) AS xid_ratio,
+                 (mx.mxid_age::numeric
+                    / NULLIF(current_setting('autovacuum_multixact_freeze_max_age')::numeric, 0)) AS mxid_ratio
+             ) r
+             WHERE r.xid_ratio >= $1 OR r.mxid_ratio >= $1
+             ORDER BY GREATEST(r.xid_ratio, r.mxid_ratio) DESC
+             LIMIT $2`,
+            [wraparoundThreshold, limit]
+          ),
+          run(
+            // Deliberately unfiltered by schema, unlike every other category
+            // in this tool: an anti-wraparound emergency is usually driven by
+            // a TOAST table (pg_toast.*) or a system catalog, and a check that
+            // only looked at user tables would report "nothing wrong" while
+            // the cluster approached a forced shutdown.
+            //
+            // relkind is restricted to relations that actually carry a
+            // frozen-xid horizon: heap ('r'), materialized view ('m'), TOAST
+            // ('t'). Everything else -- views, indexes, partitioned parents
+            // ('p'), sequences -- stores InvalidTransactionId (0) in
+            // relfrozenxid, and age('0'::xid) is a meaningless ~2.1-billion
+            // number that would flood this list with false positives. The
+            // explicit `relfrozenxid <> '0'::xid` guard catches the same case
+            // for any relkind that stops carrying a horizon in a future major.
+            //
+            // freeze_max_age resolves the per-table storage parameter
+            // (`ALTER TABLE ... SET (autovacuum_freeze_max_age = ...)`) and
+            // falls back to the cluster GUC. Without this, a table with a
+            // deliberately raised override reads as critical against the
+            // cluster default, and -- worse -- a table with a LOWERED override
+            // reads as safe when autovacuum is already forcing freezes on it.
+            // pg_options_to_table is strict, so a NULL reloptions yields zero
+            // rows and the scalar subquery returns NULL for COALESCE to
+            // absorb. multixact_freeze_max_age resolves the same way from the
+            // separate `autovacuum_multixact_freeze_max_age` storage parameter
+            // -- a table with a lowered multixact override is already being
+            // force-vacuumed while it still reads as safe against the cluster
+            // default.
+            //
+            // relminmxid is the multixact twin of relfrozenxid and moves
+            // independently of it: row-level locks (SELECT ... FOR
+            // SHARE/UPDATE, FK checks) burn multixact IDs without consuming
+            // xids, so a lock-heavy table can be at 90% of
+            // autovacuum_multixact_freeze_max_age with an age(relfrozenxid) of
+            // nearly zero. Filtering on the xid ratio alone reports that table
+            // as clean.
+            //
+            // The InvalidMultiXactId guard mirrors the relfrozenxid one as
+            // `<> '0'::xid` -- relminmxid is catalog-typed `xid` even though
+            // it holds a MultiXactId, so there is no separate type to cast to,
+            // and mxid_age('0'::xid) would return a meaningless ~4.2-billion
+            // age for any relation that has never recorded a multixact. It is
+            // expressed as a CASE yielding NULL, NOT as another AND in the
+            // WHERE: dropping those rows outright would also drop rows whose
+            // relfrozenxid IS dangerous. A NULL ratio cannot satisfy `>= $1`,
+            // so such a row can only ever be xid-triggered.
+            //
+            // ORDER BY is the GREATER of the two ratios rather than
+            // age(relfrozenxid): now that the filter is an OR, ordering on the
+            // xid age would push a multixact-critical TOAST table below the
+            // LIMIT cut and hide the exact row the operator was paged for.
+            // triggered_by is computed from the same full-precision ratios as
+            // the WHERE (not the rounded pct_* columns), so it can never
+            // disagree with why the row was returned.
+            `SELECT
+               n.nspname AS schema,
+               c.relname AS "table",
+               c.relkind AS relkind,
+               age(c.relfrozenxid) AS xid_age,
+               fma.freeze_max_age AS freeze_max_age,
+               r.xid_ratio::numeric(10, 4)::float8 AS pct_of_freeze_max_age,
+               fma.mxid_age AS mxid_age,
+               fma.multixact_freeze_max_age AS multixact_freeze_max_age,
+               r.mxid_ratio::numeric(10, 4)::float8 AS pct_of_multixact_freeze_max_age,
+               CASE
+                 WHEN r.xid_ratio >= $1 AND r.mxid_ratio >= $1 THEN 'both'
+                 WHEN r.mxid_ratio >= $1 THEN 'multixact'
+                 ELSE 'xid'
+               END AS triggered_by${frozenCoverageCols}
+             FROM pg_catalog.pg_class c
+             JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+             CROSS JOIN LATERAL (
+               SELECT
+                 COALESCE(
+                   (SELECT o.option_value::int
+                    FROM pg_catalog.pg_options_to_table(c.reloptions) o
+                    WHERE o.option_name = 'autovacuum_freeze_max_age'),
+                   current_setting('autovacuum_freeze_max_age')::int
+                 ) AS freeze_max_age,
+                 COALESCE(
+                   (SELECT o.option_value::int
+                    FROM pg_catalog.pg_options_to_table(c.reloptions) o
+                    WHERE o.option_name = 'autovacuum_multixact_freeze_max_age'),
+                   current_setting('autovacuum_multixact_freeze_max_age')::int
+                 ) AS multixact_freeze_max_age,
+                 CASE WHEN c.relminmxid <> '0'::xid THEN mxid_age(c.relminmxid) END AS mxid_age
+             ) fma
+             CROSS JOIN LATERAL (
+               SELECT
+                 (age(c.relfrozenxid)::numeric / NULLIF(fma.freeze_max_age, 0)::numeric) AS xid_ratio,
+                 (fma.mxid_age::numeric / NULLIF(fma.multixact_freeze_max_age, 0)::numeric) AS mxid_ratio
+             ) r
+             WHERE c.relkind IN ('r', 'm', 't')
+               AND c.relfrozenxid <> '0'::xid
+               AND (r.xid_ratio >= $1 OR r.mxid_ratio >= $1)
+             ORDER BY GREATEST(r.xid_ratio, r.mxid_ratio) DESC
+             LIMIT $2`,
+            [wraparoundThreshold, limit]
+          ),
           run(
             // Includes partitioned parents (relkind='p') alongside plain heap
             // tables ('r'). A partitioned table with no PK is a real design-
@@ -36802,12 +37518,32 @@ var adminTools = [
         ]);
         const warnings = [];
         if (!seqRes.ok) warnings.push(`sequence_exhaustion fetch failed: ${seqRes.error}`);
+        if (!wrapGucRes.ok) {
+          warnings.push(`wraparound_risk.autovacuum_freeze_max_age fetch failed: ${wrapGucRes.error}`);
+        }
+        if (!wrapDbRes.ok) warnings.push(`wraparound_risk.databases fetch failed: ${wrapDbRes.error}`);
+        if (!wrapTblRes.ok) warnings.push(`wraparound_risk.tables fetch failed: ${wrapTblRes.error}`);
         if (!noPkRes.ok) warnings.push(`tables_without_primary_key fetch failed: ${noPkRes.error}`);
         if (!rlsRes.ok) warnings.push(`public_tables_without_rls fetch failed: ${rlsRes.error}`);
         return {
           ok: true,
           data: {
             sequence_exhaustion: seqRes.ok ? seqRes.data : [],
+            wraparound_risk: {
+              // `?? null` rather than leaving it undefined: an absent key
+              // serializes away entirely, so a caller reading an empty
+              // `databases` list would have no way to tell "nothing above the
+              // threshold" from "the divisor was never readable".
+              autovacuum_freeze_max_age: wrapGucRes.ok ? wrapGucRes.data?.[0]?.autovacuum_freeze_max_age ?? null : null,
+              // Same `?? null` reasoning, and it is exposed even though the
+              // two GUCs share a sub-query: a caller that only saw the xid
+              // divisor would have no scale for pct_of_multixact_freeze_max_age
+              // and no way to judge an empty `databases` list on the multixact
+              // axis.
+              autovacuum_multixact_freeze_max_age: wrapGucRes.ok ? wrapGucRes.data?.[0]?.autovacuum_multixact_freeze_max_age ?? null : null,
+              databases: wrapDbRes.ok ? wrapDbRes.data : [],
+              tables: wrapTblRes.ok ? wrapTblRes.data : []
+            },
             tables_without_primary_key: noPkRes.ok ? noPkRes.data : [],
             public_tables_without_rls: rlsRes.ok ? rlsRes.data : [],
             ...warnings.length > 0 ? { _warnings: warnings } : {}
@@ -36910,7 +37646,12 @@ var adminTools = [
 ];
 
 // src/tools/explain.ts
-var indexAccessMethod = external_exports.enum(["btree", "hash", "gin", "gist", "brin", "spgist"]);
+var PG12 = 12e4;
+var PG13 = 13e4;
+var SERIALIZE_MODES = ["none", "text", "binary"];
+var serializeMode = external_exports.enum(SERIALIZE_MODES);
+var INDEX_ACCESS_METHODS = ["btree", "hash", "gin", "gist", "brin", "spgist"];
+var indexAccessMethod = external_exports.enum(INDEX_ACCESS_METHODS);
 var hypotheticalIndex = external_exports.object({
   // `table` is `schema.table` or `table`. The 127-char ceiling is a generous
   // upper bound on the combined form -- the actual NAMEDATALEN (63-byte)
@@ -36927,6 +37668,9 @@ function quoteQualifiedTable(name) {
   return name.split(".").map((p) => quoteIdent(p)).join(".");
 }
 function validateHypoIndex(idx) {
+  if (idx.using !== void 0 && !INDEX_ACCESS_METHODS.includes(idx.using)) {
+    return `Unsupported \`using\` value ${JSON.stringify(idx.using)}; expected one of: ${INDEX_ACCESS_METHODS.join(", ")}.`;
+  }
   if (idx.table.includes('"')) {
     return `Hypothetical index table ${JSON.stringify(idx.table)} contains a double-quote; pass plain identifier names without pre-quoting.`;
   }
@@ -36974,7 +37718,7 @@ function buildHypopgHooks(indexes) {
 var explainTools = [
   {
     name: "pg_explain",
-    description: "Get the query plan for a SQL statement. By default, this uses plain EXPLAIN (no execution). Set `analyze: true` to run the query with EXPLAIN ANALYZE - for non-SELECT statements, ALLOW_WRITES=1 is required (since ANALYZE actually executes the statement). Writes executed during EXPLAIN ANALYZE are always rolled back, so you can inspect a plan for an INSERT/UPDATE/DELETE without persisting the mutation. Format is `text` (default) or `json`. Pass the raw SQL (not an EXPLAIN-prefixed statement). Set `hypothetical_indexes` to a list of `{table, columns, using?}` to ask the planner 'what would the plan be if these indexes existed?' -- requires the HypoPG extension (`CREATE EXTENSION hypopg`). The hypothetical indexes are torn down at the end of the call, never touching real disk.",
+    description: "Get the query plan for a SQL statement. By default, this uses plain EXPLAIN (no execution). Set `analyze: true` to run the query with EXPLAIN ANALYZE - for non-SELECT statements, ALLOW_WRITES=1 is required (since ANALYZE actually executes the statement). Writes executed during EXPLAIN ANALYZE are always rolled back, so you can inspect a plan for an INSERT/UPDATE/DELETE without persisting the mutation. Format is `text` (default) or `json`. Pass the raw SQL (not an EXPLAIN-prefixed statement). Planner options (all optional): `buffers` reports shared/local/temp block hits and is the fastest way to tell a bad plan from a cold cache - it defaults to TRUE whenever `analyze` is true (matching PostgreSQL 18, which turns it on for you), pass `buffers: false` to suppress it; requesting it WITHOUT `analyze` needs PostgreSQL 13+. `verbose` adds output columns and schema-qualified names. `settings` (PostgreSQL 12+) lists planner GUCs set away from their defaults - the usual explanation for a plan that looks impossible. `wal` (PostgreSQL 13+) reports WAL generated and `serialize` (`none`|`text`|`binary`, PostgreSQL 17+) charges the cost of building the result rows; both require `analyze`. `memory` (PostgreSQL 17+) reports memory used by the PLANNER, so it works with or without `analyze` - use it alone to ask why planning a statement is expensive. `generic_plan` (PostgreSQL 16+) plans a parameterized statement WITHOUT values for its $1/$2 placeholders and cannot be combined with `analyze` or `params`. `costs` and `timing` default to true (as in postgres); set either to false to drop those columns, and note `timing` only applies with `analyze`. Options that need a newer server than the one connected are rejected with an explicit error naming the required version instead of a confusing parse failure. Set `hypothetical_indexes` to a list of `{table, columns, using?}` to ask the planner 'what would the plan be if these indexes existed?' -- requires the HypoPG extension (`CREATE EXTENSION hypopg`). The hypothetical indexes are torn down at the end of the call, never touching real disk.",
     annotations: {
       title: "Explain query plan",
       readOnlyHint: false,
@@ -36986,6 +37730,28 @@ var explainTools = [
       sql: external_exports.string().min(1).max(1e6).describe("The SQL statement to explain. Do NOT prefix with EXPLAIN."),
       analyze: external_exports.boolean().default(false).describe("Run EXPLAIN ANALYZE (actually executes the query)."),
       format: external_exports.enum(["text", "json"]).default("text").describe("Output format."),
+      // Deliberately NOT `.default(false)`: the effective default is "on when
+      // analyzing", which Zod cannot express in terms of a sibling field. An
+      // absent value means "follow analyze"; an explicit false still wins.
+      buffers: external_exports.boolean().optional().describe(
+        "Report buffer hits/reads/dirtied. Defaults to TRUE when `analyze` is true (PostgreSQL 18 does the same); pass false to suppress. Requesting it without `analyze` requires PostgreSQL 13+."
+      ),
+      verbose: external_exports.boolean().default(false).describe("Include output columns, schema-qualified names, and triggers."),
+      settings: external_exports.boolean().default(false).describe("Report planner GUCs set away from their defaults - explains a weird plan (PostgreSQL 12+)."),
+      wal: external_exports.boolean().default(false).describe("Report WAL generated by the statement. Requires `analyze` (PostgreSQL 13+)."),
+      memory: external_exports.boolean().default(false).describe(
+        "Report memory used by the planner (PostgreSQL 17+). Works with or without `analyze`, since planning happens either way."
+      ),
+      serialize: serializeMode.optional().describe(
+        "Charge the cost of serializing result rows (network-bound queries hide it otherwise). Requires `analyze` (PostgreSQL 17+)."
+      ),
+      generic_plan: external_exports.boolean().default(false).describe(
+        "Plan the statement with UNKNOWN values for its $1/$2 placeholders - the plan a prepared statement would get. Cannot be combined with `analyze` or `params` (PostgreSQL 16+)."
+      ),
+      costs: external_exports.boolean().default(true).describe("Include estimated cost/rows/width. Set false for a terser plan."),
+      timing: external_exports.boolean().default(true).describe(
+        "Include per-node actual timing. Setting it to false REQUIRES `analyze: true` (it is rejected otherwise, not silently ignored); false lowers measurement overhead."
+      ),
       params: paramsArray.optional().describe("Positional parameters referenced as $1, $2, ... in the SQL."),
       hypothetical_indexes: external_exports.array(hypotheticalIndex).optional().describe(
         "List of indexes the planner should pretend exist for this EXPLAIN. Requires the HypoPG extension. Indexes are session-scoped and reset at the end of the call."
@@ -36996,6 +37762,15 @@ var explainTools = [
         sql,
         analyze = false,
         format = "text",
+        buffers,
+        verbose = false,
+        settings = false,
+        wal = false,
+        memory = false,
+        serialize,
+        generic_plan = false,
+        costs = true,
+        timing = true,
         params,
         hypothetical_indexes
       } = input;
@@ -37005,15 +37780,74 @@ var explainTools = [
           error: "The `sql` parameter should be the query to explain, not an EXPLAIN statement. Use the `analyze` and `format` parameters on this tool instead of prefixing the SQL."
         };
       }
-      const flags = [];
-      if (analyze) flags.push("ANALYZE");
-      if (format === "json") flags.push("FORMAT JSON");
-      const explainSql = flags.length > 0 ? `EXPLAIN (${flags.join(", ")}) ${sql}` : `EXPLAIN ${sql}`;
+      if (serialize !== void 0 && !SERIALIZE_MODES.includes(serialize)) {
+        return {
+          ok: false,
+          error: `Unsupported \`serialize\` value ${JSON.stringify(serialize)}; expected one of: ${SERIALIZE_MODES.join(", ")}.`
+        };
+      }
+      const wantBuffers = buffers ?? analyze;
+      const analyzeOnly = [];
+      if (!analyze) {
+        if (wal) analyzeOnly.push("wal");
+        if (serialize !== void 0) analyzeOnly.push("serialize");
+        if (!timing) analyzeOnly.push("timing");
+      }
+      if (analyzeOnly.length > 0) {
+        const named = analyzeOnly.map((o) => `\`${o}\``).join(", ");
+        return {
+          ok: false,
+          error: `These EXPLAIN options only apply with \`analyze: true\`: ${named}. Set \`analyze: true\` (the statement is executed, and any write is rolled back) or drop them.`
+        };
+      }
+      if (generic_plan && analyze) {
+        return {
+          ok: false,
+          error: "`generic_plan` and `analyze` cannot be combined: GENERIC_PLAN plans the statement without parameter values, while ANALYZE has to execute it with real ones. Pick one."
+        };
+      }
+      if (generic_plan && (params?.length ?? 0) > 0) {
+        return {
+          ok: false,
+          error: "`generic_plan` plans the statement WITHOUT parameter values -- drop `params` (leave the $1/$2 placeholders in the SQL), or drop `generic_plan` and pass the values."
+        };
+      }
       const hypoIndexes = hypothetical_indexes ?? [];
       for (const idx of hypoIndexes) {
         const err = validateHypoIndex(idx);
         if (err) return { ok: false, error: err };
       }
+      const gated = [];
+      if (settings) gated.push({ option: "settings", min: PG12, since: "12" });
+      if (wal) gated.push({ option: "wal", min: PG13, since: "13" });
+      if (generic_plan) gated.push({ option: "generic_plan", min: PG16, since: "16" });
+      if (memory) gated.push({ option: "memory", min: PG17, since: "17" });
+      if (serialize !== void 0) gated.push({ option: "serialize", min: PG17, since: "17" });
+      if (wantBuffers && !analyze) gated.push({ option: "buffers without analyze", min: PG13, since: "13" });
+      if (gated.length > 0) {
+        const serverVersion = await getServerVersionNum();
+        const unsupported = gated.filter((g) => serverVersion < g.min);
+        if (unsupported.length > 0) {
+          const server2 = serverVersion === 0 ? "the server version could not be determined, so the oldest supported behavior is assumed" : `this server reports PostgreSQL ${Math.floor(serverVersion / 1e4)}`;
+          return {
+            ok: false,
+            error: `Unsupported EXPLAIN option for this server: ${unsupported.map((g) => `\`${g.option}\` requires PostgreSQL ${g.since}+`).join("; ")} (${server2}). Drop the option and re-run.`
+          };
+        }
+      }
+      const flags = [];
+      if (analyze) flags.push("ANALYZE");
+      if (wantBuffers) flags.push("BUFFERS");
+      if (verbose) flags.push("VERBOSE");
+      if (settings) flags.push("SETTINGS");
+      if (wal) flags.push("WAL");
+      if (memory) flags.push("MEMORY");
+      if (generic_plan) flags.push("GENERIC_PLAN");
+      if (!costs) flags.push("COSTS OFF");
+      if (!timing) flags.push("TIMING OFF");
+      if (serialize !== void 0) flags.push(`SERIALIZE ${serialize.toUpperCase()}`);
+      if (format === "json") flags.push("FORMAT JSON");
+      const explainSql = flags.length > 0 ? `EXPLAIN (${flags.join(", ")}) ${sql}` : `EXPLAIN ${sql}`;
       const hooks = hypoIndexes.length > 0 ? buildHypopgHooks(hypoIndexes) : {};
       if (hypoIndexes.length > 0) {
         const check2 = await runInternal(
@@ -37053,7 +37887,7 @@ var explainTools = [
 var healthTools = [
   {
     name: "pg_health",
-    description: "Quick health snapshot: server version, database size, connection count, active queries, and table count. Useful as a connection sanity check and to spot runaway queries.",
+    description: "Quick health snapshot: server version, database size, connection counts measured against `max_connections`, active queries with their wait events, a pg_stat_database rollup, and table count. Useful as a connection sanity check and to spot runaway queries, connection-cap pressure, and lock/IO waits.\n- connections: `total` for the CURRENT database, broken down into `active` / `idle` / `idle_in_transaction` / `idle_in_transaction_aborted` / `other` (starting, fastpath function call, disabled) / `state_unavailable` -- those six sum to `total`. `idle_in_transaction_aborted` is called out separately because it holds locks and blocks vacuum while doing no work and will never commit. `state_unavailable` counts sessions whose `state` reads NULL because the role lacks pg_read_all_stats / pg_monitor membership; a non-zero value means every other bucket is under-counted by at least that much, so do NOT read `active: 0` next to it as an idle database. Plus `cluster_client_backends` (client backends across ALL databases -- those are what actually consume connection slots), `max_connections`, `superuser_reserved_connections`, and `used_fraction` (cluster_client_backends / max_connections). A raw connection count means nothing without the cap; read `used_fraction` first.\n- active_queries: `pid`, `state`, `query`, `application_name`, `backend_type`, `wait_event_type` / `wait_event` (both NULL when the backend is running rather than waiting -- the single most diagnostic pair in pg_stat_activity), `duration_seconds` (since query_start) and `transaction_age_seconds` (since xact_start). A large transaction_age_seconds next to a small duration_seconds is a long-open transaction, the usual root cause behind lock waits, bloat, and stalled autovacuum.\n- database_stats: pg_stat_database for the current database -- `deadlocks`, `temp_files` / `temp_bytes` (work_mem spills), `conflicts` (recovery conflicts, only ever non-zero on a replica), `blks_hit` / `blks_read` / `cache_hit_ratio`, and `stats_reset`. Every counter is CUMULATIVE since stats_reset, not a rate -- interpret them against that timestamp.\nSub-queries that fail (several of these are permission-gated on managed providers) append to `_warnings` and leave their field null; the rest of the snapshot still returns.",
     annotations: {
       title: "Database health snapshot",
       readOnlyHint: true,
@@ -37067,7 +37901,7 @@ var healthTools = [
     handler: async (input) => {
       const { activeQueryLimit = 10 } = input;
       return withSharedClient(async (run) => {
-        const [versionRes, sizeRes, connsRes, activeRes, tableCountRes] = await Promise.all([
+        const [versionRes, sizeRes, connsRes, activeRes, dbStatsRes, tableCountRes] = await Promise.all([
           run(`SELECT version() AS version`),
           run(
             `SELECT
@@ -37076,19 +37910,97 @@ var healthTools = [
                pg_database_size(current_database())::text AS size_bytes`
           ),
           run(
+            // The per-database counters keep their original meaning: the
+            // old `WHERE datname = current_database()` moved into a FILTER on
+            // each aggregate so the same statement can also count backends in
+            // OTHER databases. Without that, a connection-cap check would
+            // compare one database's session count against a cluster-wide
+            // limit and under-report pressure on a multi-tenant server.
+            //
+            // used_fraction divides by max_connections using
+            // `backend_type = 'client backend'`, not count(*): autovacuum
+            // workers, background workers, walsenders and the checkpointer all
+            // appear in pg_stat_activity but draw on their OWN process limits,
+            // so counting them would inflate the fraction past 1.0 on an idle
+            // server. The effective ceiling for a non-superuser is lower still
+            // -- `max_connections - superuser_reserved_connections` (minus
+            // reserved_connections on PG16+) -- which is why the reserve is
+            // reported alongside rather than folded into the fraction.
+            //
+            // Visibility caveat: pg_stat_activity does NOT hide other users'
+            // rows from an ordinary role. The row is still there -- existence,
+            // datname and session user are visible to everyone -- but `state`
+            // (along with query, wait_event, xact_start, ...) comes back NULL
+            // unless the caller owns the session or holds pg_read_all_stats /
+            // pg_monitor. So `total` and cluster_client_backends, which key off
+            // datname / backend_type, are COMPLETE for any role, while the
+            // state buckets below count only the caller's own sessions. Left
+            // unmarked that renders as a confident `active: 0` on a busy
+            // database, which reads as "nothing is running" rather than "you
+            // cannot see it": state_unavailable counts the NULL-state rows so
+            // the shortfall is visible. It is a visibility gap on a successful
+            // query, not a failure, so it cannot be surfaced via _warnings.
+            //
+            // The buckets are meant to RECONCILE: every current-database row
+            // lands in exactly one of active / idle / idle_in_transaction /
+            // idle_in_transaction_aborted / other / state_unavailable, so those
+            // six sum to `total`. Keep that invariant when editing -- it is the
+            // only thing that makes a shortfall detectable.
+            //
+            // `other` is a NOT IN over the named buckets rather than one
+            // counter per remaining documented state (starting, fastpath
+            // function call, disabled): those are rare enough not to earn a
+            // field, and a catch-all also absorbs any state a future major
+            // adds, which an equality list would silently drop out of the sum.
+            // 'idle in transaction (aborted)' does get its own field -- it is
+            // an exact-equality state, not a prefix of 'idle in transaction',
+            // and it is diagnostically distinct: it holds locks and blocks
+            // vacuum while doing no work and can never commit.
             `SELECT
-               count(*)::text AS total,
-               count(*) FILTER (WHERE state = 'active')::text AS active,
-               count(*) FILTER (WHERE state = 'idle')::text AS idle,
-               count(*) FILTER (WHERE state = 'idle in transaction')::text AS idle_in_transaction
-             FROM pg_stat_activity
-             WHERE datname = current_database()`
+               count(*) FILTER (WHERE datname = current_database())::text AS total,
+               count(*) FILTER (WHERE datname = current_database() AND state = 'active')::text AS active,
+               count(*) FILTER (WHERE datname = current_database() AND state = 'idle')::text AS idle,
+               count(*) FILTER (WHERE datname = current_database() AND state = 'idle in transaction')::text AS idle_in_transaction,
+               count(*) FILTER (WHERE datname = current_database() AND state = 'idle in transaction (aborted)')::text AS idle_in_transaction_aborted,
+               count(*) FILTER (WHERE datname = current_database()
+                                  AND state IS NOT NULL
+                                  AND state NOT IN ('active', 'idle', 'idle in transaction', 'idle in transaction (aborted)'))::text AS other,
+               count(*) FILTER (WHERE datname = current_database() AND state IS NULL)::text AS state_unavailable,
+               count(*) FILTER (WHERE backend_type = 'client backend')::text AS cluster_client_backends,
+               current_setting('max_connections')::int AS max_connections,
+               current_setting('superuser_reserved_connections')::int AS superuser_reserved_connections,
+               (count(*) FILTER (WHERE backend_type = 'client backend')::numeric
+                  / NULLIF(current_setting('max_connections')::numeric, 0))::numeric(6, 4)::float8 AS used_fraction
+             FROM pg_stat_activity`
           ),
           run(
+            // wait_event_type / wait_event are the diagnostic pair here: they
+            // say WHY a backend is not making progress (Lock, LWLock, IO,
+            // Client, ...) instead of leaving the caller to infer it from the
+            // query text. Both are NULL when the backend is actually running.
+            //
+            // The values are passed straight through, never filtered or
+            // switched on: postgres renames these literals between majors
+            // (PG19 renames the `BUFFERPIN` wait event type to `BUFFER`), so
+            // any `WHERE wait_event_type = '...'` or CASE over them here would
+            // silently stop matching on a newer server. Interpretation belongs
+            // to the caller, which can see the server version.
+            //
+            // transaction_age_seconds comes from xact_start, not query_start:
+            // a backend that has been idle-in-transaction for an hour shows a
+            // short (or NULL) query duration while holding snapshots and locks
+            // the whole time. That gap is the tell for the long-open
+            // transaction behind most of the rest of this snapshot. xact_start
+            // is NULL for backends not in a transaction block.
             `SELECT
                pid,
                state,
                EXTRACT(EPOCH FROM (now() - query_start))::numeric(10, 2)::float8 AS duration_seconds,
+               EXTRACT(EPOCH FROM (now() - xact_start))::numeric(10, 2)::float8 AS transaction_age_seconds,
+               xact_start::text AS xact_start,
+               wait_event_type,
+               wait_event,
+               backend_type,
                query,
                application_name
              FROM pg_stat_activity
@@ -37100,6 +38012,32 @@ var healthTools = [
              LIMIT $1`,
             [activeQueryLimit]
           ),
+          run(
+            // Every column here is a bigint counter that has been accumulating
+            // since stats_reset, so stats_reset ships with them -- "12
+            // deadlocks" is alarming since yesterday and unremarkable since
+            // 2019. stats_reset is NULL when the stats have never been reset.
+            //
+            // ::text on the counters: they are bigint, and node-pg would hand
+            // back a JS number that silently loses precision past 2^53 on a
+            // long-lived cluster's temp_bytes.
+            //
+            // cache_hit_ratio divides in numeric rather than float8 for the
+            // same reason, and NULLIF guards the freshly-reset case where both
+            // blks_hit and blks_read are 0 (division by zero, not a 0% ratio).
+            `SELECT
+               deadlocks::text AS deadlocks,
+               temp_files::text AS temp_files,
+               temp_bytes::text AS temp_bytes,
+               pg_size_pretty(temp_bytes) AS temp_bytes_pretty,
+               conflicts::text AS conflicts,
+               blks_hit::text AS blks_hit,
+               blks_read::text AS blks_read,
+               (blks_hit::numeric / NULLIF(blks_hit + blks_read, 0))::numeric(6, 4)::float8 AS cache_hit_ratio,
+               stats_reset::text AS stats_reset
+             FROM pg_catalog.pg_stat_database
+             WHERE datname = current_database()`
+          ),
           run(
             `SELECT count(*)::text AS count
              FROM pg_catalog.pg_class c
@@ -37118,6 +38056,7 @@ var healthTools = [
         if (!sizeRes.ok) warnings.push(`database fetch failed: ${sizeRes.error}`);
         if (!connsRes.ok) warnings.push(`connections fetch failed: ${connsRes.error}`);
         if (!activeRes.ok) warnings.push(`active_queries fetch failed: ${activeRes.error}`);
+        if (!dbStatsRes.ok) warnings.push(`database_stats fetch failed: ${dbStatsRes.error}`);
         if (!tableCountRes.ok) warnings.push(`table_count fetch failed: ${tableCountRes.error}`);
         return {
           ok: true,
@@ -37127,6 +38066,12 @@ var healthTools = [
             database: sizeRes.ok ? sizeRes.data?.[0] : null,
             connections: connsRes.ok ? connsRes.data?.[0] : null,
             active_queries: activeRes.ok ? activeRes.data : [],
+            // `?? null` matters here and not on the sibling single-row
+            // lookups: pg_stat_database has no row for a database the role
+            // cannot see, so a successful query can legitimately return zero
+            // rows. Normalize that to null instead of undefined, which JSON
+            // serialization would drop from the response entirely.
+            database_stats: dbStatsRes.ok ? dbStatsRes.data?.[0] ?? null : null,
             table_count: tableCountRes.ok ? tableCountRes.data?.[0]?.count : null,
             ...warnings.length > 0 ? { _warnings: warnings } : {}
           }
@@ -37136,6 +38081,176 @@ var healthTools = [
   }
 ];
 
+// src/tools/io.ts
+var ioTools = [
+  {
+    name: "pg_io_stats",
+    description: "I/O observability: cumulative per-backend-type I/O from `pg_stat_io` (PostgreSQL 16+), plus in-flight asynchronous I/O handles from `pg_aios` (PostgreSQL 18+). This is the layer underneath `pg_top_queries` and `pg_health` -- it says WHICH subsystem is doing the I/O (client backends vs autovacuum vs checkpointer vs walwriter) and through which path, which a per-query or per-table view cannot.\n- io: one row per (`backend_type`, `io_object`, `io_context`) combination. Counters `reads` / `writes` / `extends` / `writebacks` / `hits` / `evictions` / `reuses` / `fsyncs` are bigints returned as decimal strings; `read_time_ms` / `write_time_ms` / `writeback_time_ms` / `extend_time_ms` / `fsync_time_ms` are float8 milliseconds. A timing of 0 next to a non-zero op count means `track_io_timing` is off, NOT that the I/O was free -- turn it on to get real numbers. A NULL counter means the operation is not possible for that combination, which is different from 0.\n- io[].read_bytes / write_bytes / extend_bytes: a normalized byte figure that means the same thing on every supported server. On PG16-17 it is computed as `op_bytes * <op count>`; on PG18 `op_bytes` was removed and the server reports bytes directly. The top-level `byte_accounting` field says which source produced the numbers.\n- io[].stats_reset: these are CUMULATIVE counters, so a row is only interpretable next to its reset point. Reported per row because that is how the view reports it; `pg_stat_reset_shared('io')` resets them together in practice, but this tool does not assert that.\n- Rows whose counters are all zero are omitted by default (`pg_stat_io` is mostly zeros on a quiet system, and the noise buries the handful of rows that matter). Pass `includeZeroRows: true` for the full matrix.\n- in_flight + io_method: PostgreSQL 18+ ONLY, and both keys are ABSENT on older servers rather than empty/null -- an empty `in_flight` array would read as 'nothing is stalled' when the truth is 'this server cannot tell you'. `in_flight` is live, currently-outstanding async I/O (`pid`, `io_id`, `op`, `state`, `off`, `length`, `target_desc`), which is what you want while a stall is happening rather than after it. `io_method` (`worker` / `io_uring` / `sync`) explains what `in_flight` can contain: with `io_method = sync` there is no asynchronous submission, so the array is legitimately empty no matter how much I/O is running.\nRequires PostgreSQL 16+. Sub-queries that fail (`pg_stat_io` and `pg_aios` are permission-gated on some managed providers) append to `_warnings` and set their field to null; the rest of the response still returns.",
+    annotations: {
+      title: "I/O statistics and in-flight async I/O",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    inputSchema: external_exports.object({
+      includeZeroRows: external_exports.boolean().default(false).describe(
+        "If true, return every (backend_type, io_object, io_context) row including the ones with no recorded activity. Default false -- the view is mostly zeros on a quiet system."
+      ),
+      limit: external_exports.number().int().min(1).max(1e3).default(200).describe(
+        "Max rows per section (default 200). pg_stat_io has well under 200 combinations, so this effectively bounds the in-flight list on a busy PG18 server."
+      )
+    }),
+    handler: async (input) => {
+      const { includeZeroRows = false, limit = 200 } = input;
+      const serverVersion = await getServerVersionNum();
+      if (serverVersion < PG16) {
+        const detected = serverVersion > 0 ? `this server reports server_version_num=${serverVersion}` : "this server's version could not be determined (the `server_version_num` probe failed, so the oldest supported behaviour is assumed) -- retry once before concluding the server is too old";
+        return {
+          ok: false,
+          error: `pg_io_stats requires PostgreSQL 16 or newer: ${detected}. Unlike a missing extension there is nothing to install -- \`pg_stat_io\` was added in PostgreSQL 16 and has no backport. Until the server is upgraded, use \`pg_health\` (database_stats.blks_hit / blks_read) for the cluster-wide cache picture and \`pg_top_queries\` (io_read_time_ms / io_write_time_ms, needs pg_stat_statements >= 1.10 and track_io_timing = on) for per-query I/O.`
+        };
+      }
+      const isPg18 = serverVersion >= PG18;
+      const byteCols = isPg18 ? `read_bytes::text AS read_bytes,
+               write_bytes::text AS write_bytes,
+               extend_bytes::text AS extend_bytes,` : `(reads::numeric * op_bytes)::text AS read_bytes,
+               (writes::numeric * op_bytes)::text AS write_bytes,
+               (extends::numeric * op_bytes)::text AS extend_bytes,`;
+      const byteAccounting = isPg18 ? "native read_bytes / write_bytes / extend_bytes columns (PG18+)" : "op_bytes * operation count (PG16-17; op_bytes was removed in PG18)";
+      const zeroFilter = includeZeroRows ? "" : `WHERE (COALESCE(reads, 0) + COALESCE(writes, 0) + COALESCE(extends, 0)
+                    + COALESCE(writebacks, 0) + COALESCE(hits, 0) + COALESCE(evictions, 0)
+                    + COALESCE(reuses, 0) + COALESCE(fsyncs, 0)) > 0`;
+      return withSharedClient(async (run) => {
+        const [ioRes, aiosRes, methodRes] = await Promise.all([
+          run(
+            // `object` and `context` are quoted and renamed: both are keywords
+            // (non-reserved, so bare use happens to parse today) and both are
+            // far more legible to a caller as io_object / io_context, matching
+            // how the postgres docs name the underlying enum types.
+            //
+            // Timings are NOT NULLIF'd to hide zeros, unlike pg_top_queries.
+            // There, 0 was ambiguous between "timing off" and "no IO". Here the
+            // op counters sit on the same row, so `read_time_ms: 0` next to
+            // `reads: "48213"` is an unambiguous, actionable signal that
+            // track_io_timing is off -- nulling it would destroy that.
+            //
+            // ORDER BY qualifies every counter with the table name to dodge the
+            // alias-shadowing trap documented in pg_top_queries: the SELECT
+            // aliases `reads::text AS reads`, and postgres resolves a BARE
+            // output name in ORDER BY to the output alias first, which would
+            // sort text ("9" ahead of "10"). Qualified names always route to
+            // the source bigint column.
+            `SELECT
+               backend_type,
+               "object" AS io_object,
+               context AS io_context,
+               reads::text AS reads,
+               ${byteCols}
+               read_time::numeric(18, 2)::float8 AS read_time_ms,
+               writes::text AS writes,
+               write_time::numeric(18, 2)::float8 AS write_time_ms,
+               writebacks::text AS writebacks,
+               writeback_time::numeric(18, 2)::float8 AS writeback_time_ms,
+               extends::text AS extends,
+               extend_time::numeric(18, 2)::float8 AS extend_time_ms,
+               hits::text AS hits,
+               evictions::text AS evictions,
+               reuses::text AS reuses,
+               fsyncs::text AS fsyncs,
+               fsync_time::numeric(18, 2)::float8 AS fsync_time_ms,
+               stats_reset::text AS stats_reset
+             FROM pg_catalog.pg_stat_io
+             ${zeroFilter}
+             ORDER BY (COALESCE(pg_stat_io.reads, 0) + COALESCE(pg_stat_io.writes, 0)
+                       + COALESCE(pg_stat_io.extends, 0) + COALESCE(pg_stat_io.hits, 0)) DESC,
+                      backend_type, "object", context
+             LIMIT $1`,
+            [limit]
+          ),
+          // pg_aios does not exist before PG18 -- naming it there is a 42P01
+          // that would take the whole tool down with it, so the query is not
+          // issued at all rather than issued and caught. Promise.resolve(null)
+          // keeps the Promise.all destructure positional on every version.
+          isPg18 ? run(
+            // These are handles outstanding RIGHT NOW, so there is no
+            // cumulative counter to compare against and no stats_reset to
+            // interpret them by -- the value is entirely in the snapshot.
+            // Ordered by pid so a caller can line rows up against the
+            // pg_health / pg_inspect_locks output for the same backend,
+            // which is the actual diagnostic move: "pid 4821 is blocked ->
+            // pid 4821 has 12 reads outstanding against this relation".
+            //
+            // `off` is quoted because OFF is a postgres keyword; the view's
+            // own column is spelled that way, so it has to be quoted on the
+            // input side rather than renamed away.
+            `SELECT
+                   pid,
+                   io_id,
+                   operation AS op,
+                   state,
+                   "off"::text AS "off",
+                   length::text AS length,
+                   target_desc
+                 FROM pg_catalog.pg_aios
+                 ORDER BY pid, io_id
+                 LIMIT $1`,
+            [limit]
+          ) : Promise.resolve(null),
+          // `io_method` is a PG18 GUC. The two-argument form of
+          // current_setting() returns NULL for an unknown setting instead of
+          // raising 42704, which keeps this from becoming a hard failure if a
+          // build reports >= 180000 without the parameter (an alternative
+          // distribution, a future rename). Issued separately from pg_aios on
+          // purpose: pg_aios is the permission-gated one, and losing it must
+          // not also lose the setting that explains what it would have held.
+          isPg18 ? run(`SELECT current_setting('io_method', true) AS io_method`) : Promise.resolve(null)
+        ]);
+        const warnings = [];
+        if (!ioRes.ok) warnings.push(`io fetch failed: ${ioRes.error}`);
+        if (aiosRes && !aiosRes.ok) warnings.push(`in_flight fetch failed: ${aiosRes.error}`);
+        if (methodRes && !methodRes.ok) warnings.push(`io_method fetch failed: ${methodRes.error}`);
+        return {
+          ok: true,
+          data: {
+            // Echoed so a caller can tell WHY the PG18-only keys below are
+            // absent without a second round-trip to version().
+            server_version_num: serverVersion,
+            byte_accounting: byteAccounting,
+            // Echoed because it changes what an empty `io` array means: with
+            // the filter on, empty means "no recorded I/O anywhere"; with it
+            // off, empty means the view itself returned nothing.
+            include_zero_rows: includeZeroRows,
+            // null, not [], on failure. An empty array is a real and reachable
+            // answer here (a freshly reset cluster), so it must not double as
+            // the error value -- a caller seeing [] would conclude the server
+            // is idle when it actually refused to answer. The _warnings entry
+            // above carries the reason.
+            io: ioRes.ok ? ioRes.data ?? [] : null,
+            // PG18+ keys are spread in, so on PG16/17 they are ABSENT from the
+            // response rather than null or []. That distinction is the whole
+            // point: `in_flight: []` reads as "nothing is stalled", which is a
+            // confident wrong answer on a server that has no way to look. A
+            // missing key forces the caller to notice.
+            ...isPg18 ? {
+              // NULL here is legitimate (see current_setting's missing_ok
+              // above) and is also the failure value -- disambiguated by
+              // the _warnings entry rather than by the field.
+              io_method: methodRes?.ok ? methodRes.data?.[0]?.io_method ?? null : null,
+              // Same null-on-failure reasoning as `io`, and it matters more
+              // here: this tool gets called BECAUSE something is stalling,
+              // so a permission denial that renders as "no in-flight I/O"
+              // would actively point the investigation the wrong way.
+              in_flight: aiosRes?.ok ? aiosRes.data ?? [] : null
+            } : {},
+            ...warnings.length > 0 ? { _warnings: warnings } : {}
+          }
+        };
+      });
+    }
+  }
+];
+
 // src/tools/query.ts
 var queryTools = [
   {
@@ -37267,7 +38382,7 @@ var schemaTools = [
   },
   {
     name: "pg_describe_table",
-    description: "Describe a relation: kind (table / view / materialized_view / partitioned_table / foreign_table), columns (name, type, nullable, default), primary key, foreign keys (outgoing), `referenced_by` (other tables whose FKs point at this one), `constraints` (CHECK / UNIQUE non-PK / EXCLUDE), indexes, and partition info (`partition_of` parent, `partitions` children). Works on views and materialized views too -- PK/FK/constraint/index lists will simply be empty for a plain view. Use `kind` to disambiguate before assuming you can write to the relation.",
+    description: "Describe a relation: kind (table / view / materialized_view / partitioned_table / foreign_table), columns (name, type, nullable, default, `generated`, `identity`), primary key, foreign keys (outgoing), `referenced_by` (other tables whose FKs point at this one), `constraints` (CHECK / UNIQUE non-PK / EXCLUDE), indexes, and partition info (`partition_of` parent, `partitions` children). Works on views and materialized views too -- PK/FK/constraint/index lists will simply be empty for a plain view. Use `kind` to disambiguate before assuming you can write to the relation. Generated columns (`generated`: 'stored' / 'virtual') and `identity`: 'always' columns are NOT writable -- omit them from INSERT/UPDATE column lists; a generated column's expression is reported as `generation_expression`, never as `default_value`. On PostgreSQL 18+ constraints also report `validated` / `enforced` / `has_period`, and columns report `not_null_validated` -- a NOT VALID not-null constraint means `nullable: false` can still hide NULLs.",
     annotations: {
       title: "Describe table",
       readOnlyHint: true,
@@ -37281,6 +38396,8 @@ var schemaTools = [
     }),
     handler: async (input) => {
       const { schema = "public", table } = input;
+      const serverVersion = await getServerVersionNum();
+      const isPg18 = serverVersion >= PG18;
       const kindQuery = `
         SELECT
           CASE c.relkind
@@ -37295,12 +38412,21 @@ var schemaTools = [
         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
         WHERE n.nspname = $1 AND c.relname = $2
       `;
+      const notNullValidatedCol = isPg18 ? `,
+          (SELECT COALESCE(bool_and(nn.convalidated), true)
+             FROM pg_catalog.pg_constraint nn
+            WHERE nn.contype = 'n'
+              AND nn.conrelid = a.attrelid
+              AND nn.conkey = ARRAY[a.attnum]) AS not_null_validated` : "";
       const columnsQuery = `
         SELECT
           a.attname AS name,
           pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
-          NOT a.attnotnull AS nullable,
-          pg_catalog.pg_get_expr(d.adbin, d.adrelid) AS default_value,
+          NOT a.attnotnull AS nullable${notNullValidatedCol},
+          CASE WHEN a.attgenerated = '' THEN pg_catalog.pg_get_expr(d.adbin, d.adrelid) END AS default_value,
+          CASE WHEN a.attgenerated <> '' THEN pg_catalog.pg_get_expr(d.adbin, d.adrelid) END AS generation_expression,
+          CASE a.attgenerated WHEN 's' THEN 'stored' WHEN 'v' THEN 'virtual' END AS generated,
+          CASE a.attidentity WHEN 'a' THEN 'always' WHEN 'd' THEN 'by_default' END AS identity,
           a.attnum AS ordinal_position
         FROM pg_catalog.pg_attribute a
         JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
@@ -37324,13 +38450,19 @@ var schemaTools = [
           AND i.indisprimary
         ORDER BY k.ord
       `;
+      const constraintMetaCols = isPg18 ? `,
+          con.convalidated AS validated,
+          con.conenforced AS enforced,
+          con.conperiod AS has_period` : `,
+          con.convalidated AS validated`;
+      const constraintMetaGroupBy = isPg18 ? ", con.convalidated, con.conenforced, con.conperiod" : ", con.convalidated";
       const foreignKeysQuery = `
         SELECT
           con.conname AS constraint_name,
           array_agg(att.attname::text ORDER BY u.attposition) AS columns,
           cl.relname AS foreign_table,
           fn.nspname AS foreign_schema,
-          array_agg(fatt.attname::text ORDER BY u.attposition) AS foreign_columns
+          array_agg(fatt.attname::text ORDER BY u.attposition) AS foreign_columns${constraintMetaCols}
         FROM pg_catalog.pg_constraint con
         JOIN pg_catalog.pg_class c ON c.oid = con.conrelid
         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
@@ -37347,7 +38479,7 @@ var schemaTools = [
         WHERE n.nspname = $1
           AND c.relname = $2
           AND con.contype = 'f'
-        GROUP BY con.conname, cl.relname, fn.nspname
+        GROUP BY con.conname, cl.relname, fn.nspname${constraintMetaGroupBy}
         ORDER BY con.conname
       `;
       const indexesQuery = `
@@ -37373,7 +38505,7 @@ var schemaTools = [
             WHEN 'x' THEN 'exclude'
             ELSE con.contype::text
           END AS type,
-          pg_catalog.pg_get_constraintdef(con.oid, true) AS definition
+          pg_catalog.pg_get_constraintdef(con.oid, true) AS definition${constraintMetaCols}
         FROM pg_catalog.pg_constraint con
         JOIN pg_catalog.pg_class c ON c.oid = con.conrelid
         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
@@ -37388,7 +38520,7 @@ var schemaTools = [
           srcn.nspname AS schema,
           src.relname AS "table",
           array_agg(srcatt.attname::text ORDER BY u.attposition) AS columns,
-          array_agg(refatt.attname::text ORDER BY u.attposition) AS referenced_columns
+          array_agg(refatt.attname::text ORDER BY u.attposition) AS referenced_columns${constraintMetaCols}
         FROM pg_catalog.pg_constraint con
         JOIN pg_catalog.pg_class src ON src.oid = con.conrelid
         JOIN pg_catalog.pg_namespace srcn ON srcn.oid = src.relnamespace
@@ -37405,7 +38537,7 @@ var schemaTools = [
         WHERE refn.nspname = $1
           AND ref.relname = $2
           AND con.contype = 'f'
-        GROUP BY con.conname, srcn.nspname, src.relname
+        GROUP BY con.conname, srcn.nspname, src.relname${constraintMetaGroupBy}
         ORDER BY srcn.nspname, src.relname, con.conname
       `;
       const partitionParentQuery = `
@@ -37457,6 +38589,11 @@ var schemaTools = [
         }
         const kind = kindRes.ok ? kindRes.data?.[0]?.kind ?? "table" : "table";
         const warnings = [];
+        if (serverVersion === 0) {
+          warnings.push(
+            "server version unknown; PG18-only fields omitted (constraint `enforced`/`has_period`, column `not_null_validated`)"
+          );
+        }
         if (!kindRes.ok) warnings.push(`kind fetch failed, reported as "table": ${kindRes.error}`);
         else if ((kindRes.data?.length ?? 0) === 0) warnings.push(`kind unavailable, reported as "table"`);
         if (!pk.ok) warnings.push(`primary_key fetch failed: ${pk.error}`);
@@ -37624,10 +38761,24 @@ var schemaTools = [
 ];
 
 // src/tools/stats.ts
+var STATS_RESET_SQL = `SELECT
+     stats_reset::text AS stats_reset,
+     EXTRACT(EPOCH FROM (now() - stats_reset))::numeric(14, 2)::float8 AS stats_reset_age_seconds
+   FROM pg_catalog.pg_stat_database
+   WHERE datname = current_database()`;
+var PG_STAT_STATEMENTS_INFO_MIN_VERSION = "1.9";
+function hasStatementsInfo(extVersion) {
+  return compareVersions(extVersion, PG_STAT_STATEMENTS_INFO_MIN_VERSION) >= 0;
+}
+var STATEMENTS_STATS_RESET_SQL = `SELECT
+     stats_reset::text AS stats_reset,
+     EXTRACT(EPOCH FROM (now() - stats_reset))::numeric(14, 2)::float8 AS stats_reset_age_seconds,
+     dealloc::text AS dealloc
+   FROM pg_stat_statements_info`;
 var statsTools = [
   {
     name: "pg_top_queries",
-    description: "Top N queries by total or mean execution time. Requires the `pg_stat_statements` extension to be installed and enabled (most managed Postgres providers have it on by default). Returns normalized query text (constants replaced with `?`), call count, total/mean/min/max time in ms, rows returned, and cache hit ratio. Use this to find slow queries worth optimizing. On pg_stat_statements >= 1.10 (Postgres 15+), also returns `io_read_time_ms` and `io_write_time_ms` to separate IO-bound from CPU-bound queries (null when track_io_timing = off or the query did no measurable IO -- enable track_io_timing in postgresql.conf to get non-null values). Scoped to the database in DATABASE_URL: pg_stat_statements is cluster-wide, so results are filtered by `dbid` to match every other tool here rather than leaking query text from unrelated databases sharing the cluster.",
+    description: "Top N queries by total or mean execution time. Requires the `pg_stat_statements` extension to be installed and enabled (most managed Postgres providers have it on by default). Returns `{rows, stats_reset, stats_reset_age_seconds, dealloc}`: each row has normalized query text (constants replaced with `?`), call count, total/mean/min/max time in ms, rows returned, and cache hit ratio. Use this to find slow queries worth optimizing.\n`calls` and `total_time_ms` are cumulative since the last `pg_stat_statements_reset()`, so this ranking only describes the window that started at the top-level `stats_reset` (with `stats_reset_age_seconds` beside it). This is pg_stat_statements' OWN reset clock, read from `pg_stat_statements_info` -- it is independent of the `stats_reset` reported by `pg_seq_scan_tables` / `pg_unused_indexes`, which comes from pg_stat_database, so do not compare the two timestamps or assume one implies the other. `stats_reset: null` means the start of the window is unknown, not that it covers all time.\nREAD `dealloc` BEFORE TRUSTING THE RANKING: it counts how many times entries for the LEAST-EXECUTED statements were evicted because more distinct statements were seen than `pg_stat_statements.max` allows. A non-zero `dealloc` means this ranking is drawn from an INCOMPLETE population -- queries may be missing from these results entirely, and an evicted query's counters restart from zero if it runs again, understating it. The larger `dealloc` is, the more churn, so 'not in the top N' stops being evidence that a query is cheap. Raise `pg_stat_statements.max` to get a complete picture.\nOn pg_stat_statements < 1.9 (before Postgres 14) `pg_stat_statements_info` does not exist, so `stats_reset`, `stats_reset_age_seconds` and `dealloc` are omitted entirely rather than returned as nulls, and a `_warnings` entry says so.\nOn pg_stat_statements >= 1.10 (Postgres 15+), also returns `io_read_time_ms` and `io_write_time_ms` to separate IO-bound from CPU-bound queries (null when track_io_timing = off or the query did no measurable IO -- enable track_io_timing in postgresql.conf to get non-null values). Scoped to the database in DATABASE_URL: pg_stat_statements is cluster-wide, so results are filtered by `dbid` to match every other tool here rather than leaking query text from unrelated databases sharing the cluster.",
     annotations: {
       title: "Top queries by execution time",
       readOnlyHint: true,
@@ -37663,12 +38814,15 @@ var statsTools = [
            NULLIF(${hasSharedBlkCols ? "shared_blk_read_time" : "blk_read_time"}, 0)::numeric(18, 2)::float8 AS io_read_time_ms,
            NULLIF(${hasSharedBlkCols ? "shared_blk_write_time" : "blk_write_time"}, 0)::numeric(18, 2)::float8 AS io_write_time_ms` : "";
       const orderCol = orderBy === "total_time" ? totalCol : orderBy === "mean_time" ? meanCol : "pg_stat_statements.calls";
-      return runInternal(
-        // bigint counters (calls, rows) come back as `.text` for lossless
-        // serialization, matching pg_seq_scan_tables / pg_unused_indexes /
-        // pg_table_bloat. Timing fields stay as float8 because they are
-        // inherently fractional milliseconds.
-        `SELECT
+      const infoSql = hasStatementsInfo(extVersion) ? STATEMENTS_STATS_RESET_SQL : null;
+      return withSharedClient(async (run) => {
+        const [rowsRes, infoRes] = await Promise.all([
+          run(
+            // bigint counters (calls, rows) come back as `.text` for lossless
+            // serialization, matching pg_seq_scan_tables / pg_unused_indexes /
+            // pg_table_bloat. Timing fields stay as float8 because they are
+            // inherently fractional milliseconds.
+            `SELECT
            query,
            calls::text AS calls,
            ${totalCol}::numeric(18, 2)::float8 AS total_time_ms,
@@ -37685,13 +38839,29 @@ var statsTools = [
          WHERE dbid = (SELECT oid FROM pg_catalog.pg_database WHERE datname = current_database())
          ORDER BY ${orderCol} DESC NULLS LAST
          LIMIT $1`,
-        [limit]
-      );
+            [limit]
+          ),
+          infoSql ? run(infoSql) : null
+        ]);
+        if (!rowsRes.ok) return { ok: false, error: rowsRes.error };
+        if (!infoRes) {
+          return {
+            ok: true,
+            data: {
+              rows: rowsRes.data ?? [],
+              _warnings: [
+                `pg_stat_statements ${extVersion} predates pg_stat_statements_info (added in ${PG_STAT_STATEMENTS_INFO_MIN_VERSION}), so the reset point and the dealloc eviction count are unavailable: this ranking's window and completeness are unknown`
+              ]
+            }
+          };
+        }
+        return { ok: true, data: withStatsReset(rowsRes.data ?? [], infoRes, "pg_stat_statements_info") };
+      });
     }
   },
   {
     name: "pg_seq_scan_tables",
-    description: "Tables with high sequential-scan counts relative to index scans - the first place to look for missing-index candidates. Returns seq_scans, idx_scans, live tuples, and the ratio. A high ratio on a large table usually means a query is reading the whole table where an index would suffice. Pair with `pg_top_queries` to find which query is doing it.",
+    description: "Tables with high sequential-scan counts relative to index scans - the first place to look for missing-index candidates. Returns `{rows, stats_reset, stats_reset_age_seconds}`: each row has seq_scans, idx_scans, live tuples, and the ratio. A high ratio on a large table usually means a query is reading the whole table where an index would suffice. Pair with `pg_top_queries` to find which query is doing it.\nThese counters are cumulative since the last statistics reset, so every ratio here is only meaningful relative to the top-level `stats_reset` (and `stats_reset_age_seconds`). A ratio measured over a window that was reset minutes ago describes that window, not the workload; `stats_reset: null` means the start of the window is unknown.\nOn PostgreSQL 16+ each row also carries `last_seq_scan` and `last_idx_scan` timestamps (null = no such scan since the reset), which separate 'scanned hard months ago' from 'being scanned right now' in a way the raw counts cannot.",
     annotations: {
       title: "Find tables with heavy sequential scans",
       readOnlyHint: true,
@@ -37710,33 +38880,41 @@ var statsTools = [
         minSize = 1e3,
         limit = 20
       } = input;
+      const serverVersion = await getServerVersionNum();
       const schemaFilter = schema ? "AND schemaname = $3" : "AND schemaname NOT IN ('pg_catalog', 'information_schema') AND schemaname NOT LIKE 'pg_%'";
       const params = [minSize, limit];
       if (schema) params.push(schema);
-      return runInternal(
-        `SELECT
-           schemaname AS schema,
-           relname AS "table",
-           seq_scan::text AS seq_scans,
-           COALESCE(idx_scan, 0)::text AS idx_scans,
-           n_live_tup::text AS live_tuples,
-           seq_tup_read::text AS seq_tup_read,
-           CASE
-             WHEN COALESCE(idx_scan, 0) = 0 THEN NULL
-             ELSE (seq_scan::numeric / idx_scan)::numeric(10, 2)::float8
-           END AS ratio
-         FROM pg_catalog.pg_stat_user_tables
-         WHERE n_live_tup >= $1
-           ${schemaFilter}
-         ORDER BY seq_scan DESC NULLS LAST
-         LIMIT $2`,
-        params
-      );
+      return withSharedClient(async (run) => {
+        const [rowsRes, resetRes] = await Promise.all([
+          run(
+            `SELECT
+               schemaname AS schema,
+               relname AS "table",
+               seq_scan::text AS seq_scans,
+               COALESCE(idx_scan, 0)::text AS idx_scans,
+               n_live_tup::text AS live_tuples,
+               seq_tup_read::text AS seq_tup_read,
+               CASE
+                 WHEN COALESCE(idx_scan, 0) = 0 THEN NULL
+                 ELSE (seq_scan::numeric / idx_scan)::numeric(10, 2)::float8
+               END AS ratio${tableLastScanCols(serverVersion)}
+             FROM pg_catalog.pg_stat_user_tables
+             WHERE n_live_tup >= $1
+               ${schemaFilter}
+             ORDER BY seq_scan DESC NULLS LAST
+             LIMIT $2`,
+            params
+          ),
+          run(STATS_RESET_SQL)
+        ]);
+        if (!rowsRes.ok) return { ok: false, error: rowsRes.error };
+        return { ok: true, data: withStatsReset(rowsRes.data ?? [], resetRes) };
+      });
     }
   },
   {
     name: "pg_unused_indexes",
-    description: "Indexes that have never been scanned or have very low usage. Each unused index costs write amplification (every INSERT/UPDATE maintains it) and disk space. Excludes primary keys and unique constraints (which are load-bearing even with zero scans). Use this before adding new indexes - sometimes the fix is to drop a dead one.",
+    description: "Indexes that have never been scanned or have very low usage, largest first. Each unused index costs write amplification (every INSERT/UPDATE maintains it) and disk space, so before adding a new index, check whether the fix is to drop a dead one. Returns `{rows, stats_reset, stats_reset_age_seconds}`.\nREAD THIS BEFORE RECOMMENDING A DROP: `scans` is a counter, not a verdict. It only counts since the last statistics reset, which is why the top-level `stats_reset` and `stats_reset_age_seconds` are part of the answer. If the counters were reset an hour ago, EVERY index looks unused; if `stats_reset` is null, the start of the window is unknown and the counts prove nothing. This list is only trustworthy once the reset age comfortably exceeds the slowest cycle that could use the index - a monthly report, a quarterly close, a yearly job, a failover-only query path.\nPRIMARY KEY and UNIQUE indexes are already excluded from these results: they enforce a constraint and stay load-bearing at zero scans, so they never appear here and their absence is not evidence of anything.\nOn PostgreSQL 16+ each row also carries `last_idx_scan`, the timestamp of the most recent scan (null = never scanned since the reset). 'Not scanned since 2026-02-14' is a far better basis for a decision than a bare count.\nOn PostgreSQL 18+, do not fall back on the old 'the leading column is never filtered, so this index is dead weight' reasoning. Skip scan lets the planner use a multi-column btree whose leading column is unconstrained, so such an index can now be doing real work.",
     annotations: {
       title: "Find unused indexes",
       readOnlyHint: true,
@@ -37755,31 +38933,74 @@ var statsTools = [
         maxScans = 10,
         limit = 50
       } = input;
+      const serverVersion = await getServerVersionNum();
       const schemaFilter = schema ? "AND s.schemaname = $3" : "AND s.schemaname NOT IN ('pg_catalog', 'information_schema') AND s.schemaname NOT LIKE 'pg_%'";
       const params = [maxScans, limit];
       if (schema) params.push(schema);
-      return runInternal(
-        `SELECT
-           s.schemaname AS schema,
-           s.relname AS "table",
-           s.indexrelname AS "index",
-           s.idx_scan::text AS scans,
-           pg_size_pretty(pg_relation_size(s.indexrelid)) AS size_pretty,
-           pg_relation_size(s.indexrelid)::text AS size_bytes,
-           pg_catalog.pg_get_indexdef(s.indexrelid) AS definition
-         FROM pg_catalog.pg_stat_user_indexes s
-         JOIN pg_catalog.pg_index i ON i.indexrelid = s.indexrelid
-         WHERE s.idx_scan <= $1
-           AND NOT i.indisunique
-           AND NOT i.indisprimary
-           ${schemaFilter}
-         ORDER BY pg_relation_size(s.indexrelid) DESC
-         LIMIT $2`,
-        params
-      );
+      return withSharedClient(async (run) => {
+        const [rowsRes, resetRes] = await Promise.all([
+          run(
+            `SELECT
+               s.schemaname AS schema,
+               s.relname AS "table",
+               s.indexrelname AS "index",
+               s.idx_scan::text AS scans,
+               pg_size_pretty(pg_relation_size(s.indexrelid)) AS size_pretty,
+               pg_relation_size(s.indexrelid)::text AS size_bytes,
+               pg_catalog.pg_get_indexdef(s.indexrelid) AS definition${indexLastScanCols(serverVersion)}
+             FROM pg_catalog.pg_stat_user_indexes s
+             JOIN pg_catalog.pg_index i ON i.indexrelid = s.indexrelid
+             WHERE s.idx_scan <= $1
+               AND NOT i.indisunique
+               AND NOT i.indisprimary
+               ${schemaFilter}
+             ORDER BY pg_relation_size(s.indexrelid) DESC
+             LIMIT $2`,
+            params
+          ),
+          run(STATS_RESET_SQL)
+        ]);
+        if (!rowsRes.ok) return { ok: false, error: rowsRes.error };
+        return { ok: true, data: withStatsReset(rowsRes.data ?? [], resetRes) };
+      });
     }
   }
 ];
+function withStatsReset(rows, resetRes, sourceView = "pg_stat_database") {
+  if (!resetRes.ok) {
+    return {
+      rows,
+      stats_reset: null,
+      stats_reset_age_seconds: null,
+      _warnings: [`stats_reset lookup failed, so counter age is unknown: ${resetRes.error}`]
+    };
+  }
+  const row = resetRes.data?.[0];
+  if (!row) {
+    return {
+      rows,
+      stats_reset: null,
+      stats_reset_age_seconds: null,
+      _warnings: [`${sourceView} returned no row, so counter age is unknown`]
+    };
+  }
+  const out = {
+    rows,
+    stats_reset: row.stats_reset,
+    stats_reset_age_seconds: row.stats_reset_age_seconds
+  };
+  if (row.dealloc !== void 0) out.dealloc = row.dealloc;
+  return out;
+}
+function indexLastScanCols(serverVersionNum2) {
+  return serverVersionNum2 >= PG16 ? `,
+               s.last_idx_scan::text AS last_idx_scan` : "";
+}
+function tableLastScanCols(serverVersionNum2) {
+  return serverVersionNum2 >= PG16 ? `,
+               last_seq_scan::text AS last_seq_scan,
+               last_idx_scan::text AS last_idx_scan` : "";
+}
 function compareVersions(a, b) {
   const parse3 = (v) => v.split(".").map((seg) => {
     const m = seg.match(/^\d+/);
@@ -37796,7 +39017,7 @@ function compareVersions(a, b) {
 }
 
 // src/index.ts
-var version2 = true ? "0.10.0" : await readPackageVersion();
+var version2 = true ? "0.11.0" : await readPackageVersion();
 var subcommand = process.argv[2];
 if (subcommand === "version" || subcommand === "--version") {
   console.log(version2);
@@ -37815,17 +39036,33 @@ Usage:
   writeSync(2, message);
   process.exit(1);
 }
-var allTools = [...queryTools, ...schemaTools, ...explainTools, ...healthTools, ...statsTools, ...adminTools];
+var allTools = [
+  ...queryTools,
+  ...schemaTools,
+  ...explainTools,
+  ...healthTools,
+  ...statsTools,
+  ...ioTools,
+  ...adminTools
+];
 var server = new McpServer({
   name: "@yawlabs/postgres-mcp",
   version: version2
 });
 for (const tool of allTools) {
-  server.tool(
+  server.registerTool(
     tool.name,
-    tool.description,
-    tool.inputSchema.shape,
-    tool.annotations,
+    {
+      // `title` at the top level is where the current spec puts a tool's
+      // display name; `annotations.title` is the older location. Emit BOTH --
+      // dropping the annotations copy would regress hosts that only read it,
+      // and omitting the top-level one leaves newer hosts showing the raw
+      // `pg_*` name.
+      title: tool.annotations.title,
+      description: tool.description,
+      inputSchema: tool.inputSchema.shape,
+      annotations: tool.annotations
+    },
     wrapToolHandler(tool.handler)
   );
 }