prisma-sql 1.75.5 → 1.75.7

package/dist/generator.js

@@ -1,11 +1,4 @@
 #!/usr/bin/env node
-import net from 'net';
-import tls from 'tls';
-import crypto from 'crypto';
-import Stream from 'stream';
-import { performance as performance$1 } from 'perf_hooks';
-import os from 'os';
-import fs from 'fs';
 import { generatorHandler } from '@prisma/generator-helper';
 import { convertDMMFToModels, processAllDirectives, isDynamicParameter, extractDynamicName } from '@dee-wan/schema-parser';
 import { mkdir, writeFile } from 'fs/promises';
@@ -21,30 +14,22 @@ var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
-var __pow = Math.pow;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b2) => {
-  for (var prop in b2 || (b2 = {}))
-    if (__hasOwnProp.call(b2, prop))
-      __defNormalProp(a, prop, b2[prop]);
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
   if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b2)) {
-      if (__propIsEnum.call(b2, prop))
-        __defNormalProp(a, prop, b2[prop]);
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps = (a, b2) => __defProps(a, __getOwnPropDescs(b2));
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -78,2247 +63,19 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// node_modules/postgres/src/query.js
-function cachedError(xs) {
-  if (originCache.has(xs))
-    return originCache.get(xs);
-  const x = Error.stackTraceLimit;
-  Error.stackTraceLimit = 4;
-  originCache.set(xs, new Error());
-  Error.stackTraceLimit = x;
-  return originCache.get(xs);
-}
-var originCache, originStackCache, originError, CLOSE, Query;
-var init_query = __esm({
-  "node_modules/postgres/src/query.js"() {
-    originCache = /* @__PURE__ */ new Map();
-    originStackCache = /* @__PURE__ */ new Map();
-    originError = /* @__PURE__ */ Symbol("OriginError");
-    CLOSE = {};
-    Query = class extends Promise {
-      constructor(strings, args, handler, canceller, options = {}) {
-        let resolve3, reject;
-        super((a, b2) => {
-          resolve3 = a;
-          reject = b2;
-        });
-        this.tagged = Array.isArray(strings.raw);
-        this.strings = strings;
-        this.args = args;
-        this.handler = handler;
-        this.canceller = canceller;
-        this.options = options;
-        this.state = null;
-        this.statement = null;
-        this.resolve = (x) => (this.active = false, resolve3(x));
-        this.reject = (x) => (this.active = false, reject(x));
-        this.active = false;
-        this.cancelled = null;
-        this.executed = false;
-        this.signature = "";
-        this[originError] = this.handler.debug ? new Error() : this.tagged && cachedError(this.strings);
-      }
-      get origin() {
-        return (this.handler.debug ? this[originError].stack : this.tagged && originStackCache.has(this.strings) ? originStackCache.get(this.strings) : originStackCache.set(this.strings, this[originError].stack).get(this.strings)) || "";
-      }
-      static get [Symbol.species]() {
-        return Promise;
-      }
-      cancel() {
-        return this.canceller && (this.canceller(this), this.canceller = null);
-      }
-      simple() {
-        this.options.simple = true;
-        this.options.prepare = false;
-        return this;
-      }
-      readable() {
-        return __async(this, null, function* () {
-          this.simple();
-          this.streaming = true;
-          return this;
-        });
-      }
-      writable() {
-        return __async(this, null, function* () {
-          this.simple();
-          this.streaming = true;
-          return this;
-        });
-      }
-      cursor(rows = 1, fn) {
-        this.options.simple = false;
-        if (typeof rows === "function") {
-          fn = rows;
-          rows = 1;
-        }
-        this.cursorRows = rows;
-        if (typeof fn === "function")
-          return this.cursorFn = fn, this;
-        let prev;
-        return {
-          [Symbol.asyncIterator]: () => ({
-            next: () => {
-              if (this.executed && !this.active)
-                return { done: true };
-              prev && prev();
-              const promise = new Promise((resolve3, reject) => {
-                this.cursorFn = (value) => {
-                  resolve3({ value, done: false });
-                  return new Promise((r) => prev = r);
-                };
-                this.resolve = () => (this.active = false, resolve3({ done: true }));
-                this.reject = (x) => (this.active = false, reject(x));
-              });
-              this.execute();
-              return promise;
-            },
-            return() {
-              prev && prev(CLOSE);
-              return { done: true };
-            }
-          })
-        };
-      }
-      describe() {
-        this.options.simple = false;
-        this.onlyDescribe = this.options.prepare = true;
-        return this;
-      }
-      stream() {
-        throw new Error(".stream has been renamed to .forEach");
-      }
-      forEach(fn) {
-        this.forEachFn = fn;
-        this.handle();
-        return this;
-      }
-      raw() {
-        this.isRaw = true;
-        return this;
-      }
-      values() {
-        this.isRaw = "values";
-        return this;
-      }
-      handle() {
-        return __async(this, null, function* () {
-          !this.executed && (this.executed = true) && (yield 1) && this.handler(this);
-        });
-      }
-      execute() {
-        this.handle();
-        return this;
-      }
-      then() {
-        this.handle();
-        return super.then.apply(this, arguments);
-      }
-      catch() {
-        this.handle();
-        return super.catch.apply(this, arguments);
-      }
-      finally() {
-        this.handle();
-        return super.finally.apply(this, arguments);
-      }
-    };
-  }
-});
-
-// node_modules/postgres/src/errors.js
-function connection(x, options, socket) {
-  const { host, port } = socket || options;
-  const error = Object.assign(
-    new Error("write " + x + " " + (options.path || host + ":" + port)),
-    {
-      code: x,
-      errno: x,
-      address: options.path || host
-    },
-    options.path ? {} : { port }
-  );
-  Error.captureStackTrace(error, connection);
-  return error;
-}
-function postgres(x) {
-  const error = new PostgresError(x);
-  Error.captureStackTrace(error, postgres);
-  return error;
-}
-function generic(code, message) {
-  const error = Object.assign(new Error(code + ": " + message), { code });
-  Error.captureStackTrace(error, generic);
-  return error;
-}
-function notSupported(x) {
-  const error = Object.assign(
-    new Error(x + " (B) is not supported"),
-    {
-      code: "MESSAGE_NOT_SUPPORTED",
-      name: x
-    }
-  );
-  Error.captureStackTrace(error, notSupported);
-  return error;
-}
-var PostgresError, Errors;
-var init_errors = __esm({
-  "node_modules/postgres/src/errors.js"() {
-    PostgresError = class extends Error {
-      constructor(x) {
-        super(x.message);
-        this.name = this.constructor.name;
-        Object.assign(this, x);
-      }
-    };
-    Errors = {
-      connection,
-      postgres,
-      generic,
-      notSupported
-    };
-  }
-});
-
-// node_modules/postgres/src/types.js
-function handleValue(x, parameters, types2, options) {
-  let value = x instanceof Parameter ? x.value : x;
-  if (value === void 0) {
-    x instanceof Parameter ? x.value = options.transform.undefined : value = x = options.transform.undefined;
-    if (value === void 0)
-      throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
-  }
-  return "$" + types2.push(
-    x instanceof Parameter ? (parameters.push(x.value), x.array ? x.array[x.type || inferType(x.value)] || x.type || firstIsString(x.value) : x.type) : (parameters.push(x), inferType(x))
-  );
-}
-function stringify(q, string, value, parameters, types2, options) {
-  for (let i = 1; i < q.strings.length; i++) {
-    string += stringifyValue(string, value, parameters, types2, options) + q.strings[i];
-    value = q.args[i];
-  }
-  return string;
-}
-function stringifyValue(string, value, parameters, types2, o) {
-  return value instanceof Builder ? value.build(string, parameters, types2, o) : value instanceof Query ? fragment(value, parameters, types2, o) : value instanceof Identifier ? value.value : value && value[0] instanceof Query ? value.reduce((acc, x) => acc + " " + fragment(x, parameters, types2, o), "") : handleValue(value, parameters, types2, o);
-}
-function fragment(q, parameters, types2, options) {
-  q.fragment = true;
-  return stringify(q, q.strings[0], q.args[0], parameters, types2, options);
-}
-function valuesBuilder(first, parameters, types2, columns, options) {
-  return first.map(
-    (row) => "(" + columns.map(
-      (column) => stringifyValue("values", row[column], parameters, types2, options)
-    ).join(",") + ")"
-  ).join(",");
-}
-function values(first, rest, parameters, types2, options) {
-  const multi = Array.isArray(first[0]);
-  const columns = rest.length ? rest.flat() : Object.keys(multi ? first[0] : first);
-  return valuesBuilder(multi ? first : [first], parameters, types2, columns, options);
-}
-function select(first, rest, parameters, types2, options) {
-  typeof first === "string" && (first = [first].concat(rest));
-  if (Array.isArray(first))
-    return escapeIdentifiers(first, options);
-  let value;
-  const columns = rest.length ? rest.flat() : Object.keys(first);
-  return columns.map((x) => {
-    value = first[x];
-    return (value instanceof Query ? fragment(value, parameters, types2, options) : value instanceof Identifier ? value.value : handleValue(value, parameters, types2, options)) + " as " + escapeIdentifier(options.transform.column.to ? options.transform.column.to(x) : x);
-  }).join(",");
-}
-function notTagged() {
-  throw Errors.generic("NOT_TAGGED_CALL", "Query not called as a tagged template literal");
-}
-function firstIsString(x) {
-  if (Array.isArray(x))
-    return firstIsString(x[0]);
-  return typeof x === "string" ? 1009 : 0;
-}
-function typeHandlers(types2) {
-  return Object.keys(types2).reduce((acc, k) => {
-    types2[k].from && [].concat(types2[k].from).forEach((x) => acc.parsers[x] = types2[k].parse);
-    if (types2[k].serialize) {
-      acc.serializers[types2[k].to] = types2[k].serialize;
-      types2[k].from && [].concat(types2[k].from).forEach((x) => acc.serializers[x] = types2[k].serialize);
-    }
-    return acc;
-  }, { parsers: {}, serializers: {} });
-}
-function escapeIdentifiers(xs, { transform: { column } }) {
-  return xs.map((x) => escapeIdentifier(column.to ? column.to(x) : x)).join(",");
-}
-function arrayEscape(x) {
-  return x.replace(escapeBackslash, "\\\\").replace(escapeQuote, '\\"');
-}
-function arrayParserLoop(s, x, parser, typarray) {
-  const xs = [];
-  const delimiter = typarray === 1020 ? ";" : ",";
-  for (; s.i < x.length; s.i++) {
-    s.char = x[s.i];
-    if (s.quoted) {
-      if (s.char === "\\") {
-        s.str += x[++s.i];
-      } else if (s.char === '"') {
-        xs.push(parser ? parser(s.str) : s.str);
-        s.str = "";
-        s.quoted = x[s.i + 1] === '"';
-        s.last = s.i + 2;
-      } else {
-        s.str += s.char;
-      }
-    } else if (s.char === '"') {
-      s.quoted = true;
-    } else if (s.char === "{") {
-      s.last = ++s.i;
-      xs.push(arrayParserLoop(s, x, parser, typarray));
-    } else if (s.char === "}") {
-      s.quoted = false;
-      s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i));
-      s.last = s.i + 1;
-      break;
-    } else if (s.char === delimiter && s.p !== "}" && s.p !== '"') {
-      xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i));
-      s.last = s.i + 1;
-    }
-    s.p = s.char;
-  }
-  s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i + 1)) : x.slice(s.last, s.i + 1));
-  return xs;
-}
-function createJsonTransform(fn) {
-  return function jsonTransform(x, column) {
-    return typeof x === "object" && x !== null && (column.type === 114 || column.type === 3802) ? Array.isArray(x) ? x.map((x2) => jsonTransform(x2, column)) : Object.entries(x).reduce((acc, [k, v]) => Object.assign(acc, { [fn(k)]: jsonTransform(v, column) }), {}) : x;
-  };
-}
-var types, NotTagged, Identifier, Parameter, Builder, defaultHandlers, builders, serializers, parsers, mergeUserTypes, escapeIdentifier, inferType, escapeBackslash, escapeQuote, arraySerializer, arrayParserState, arrayParser, toCamel, toPascal, toKebab, fromCamel, fromPascal, fromKebab, camel, pascal, kebab;
-var init_types = __esm({
-  "node_modules/postgres/src/types.js"() {
-    init_query();
-    init_errors();
-    types = {
-      string: {
-        to: 25,
-        from: null,
-        // defaults to string
-        serialize: (x) => "" + x
-      },
-      number: {
-        to: 0,
-        from: [21, 23, 26, 700, 701],
-        serialize: (x) => "" + x,
-        parse: (x) => +x
-      },
-      json: {
-        to: 114,
-        from: [114, 3802],
-        serialize: (x) => JSON.stringify(x),
-        parse: (x) => JSON.parse(x)
-      },
-      boolean: {
-        to: 16,
-        from: 16,
-        serialize: (x) => x === true ? "t" : "f",
-        parse: (x) => x === "t"
-      },
-      date: {
-        to: 1184,
-        from: [1082, 1114, 1184],
-        serialize: (x) => (x instanceof Date ? x : new Date(x)).toISOString(),
-        parse: (x) => new Date(x)
-      },
-      bytea: {
-        to: 17,
-        from: 17,
-        serialize: (x) => "\\x" + Buffer.from(x).toString("hex"),
-        parse: (x) => Buffer.from(x.slice(2), "hex")
-      }
-    };
-    NotTagged = class {
-      then() {
-        notTagged();
-      }
-      catch() {
-        notTagged();
-      }
-      finally() {
-        notTagged();
-      }
-    };
-    Identifier = class extends NotTagged {
-      constructor(value) {
-        super();
-        this.value = escapeIdentifier(value);
-      }
-    };
-    Parameter = class extends NotTagged {
-      constructor(value, type, array) {
-        super();
-        this.value = value;
-        this.type = type;
-        this.array = array;
-      }
-    };
-    Builder = class extends NotTagged {
-      constructor(first, rest) {
-        super();
-        this.first = first;
-        this.rest = rest;
-      }
-      build(before, parameters, types2, options) {
-        const keyword = builders.map(([x, fn]) => ({ fn, i: before.search(x) })).sort((a, b2) => a.i - b2.i).pop();
-        return keyword.i === -1 ? escapeIdentifiers(this.first, options) : keyword.fn(this.first, this.rest, parameters, types2, options);
-      }
-    };
-    defaultHandlers = typeHandlers(types);
-    builders = Object.entries({
-      values,
-      in: (...xs) => {
-        const x = values(...xs);
-        return x === "()" ? "(null)" : x;
-      },
-      select,
-      as: select,
-      returning: select,
-      "\\(": select,
-      update(first, rest, parameters, types2, options) {
-        return (rest.length ? rest.flat() : Object.keys(first)).map(
-          (x) => escapeIdentifier(options.transform.column.to ? options.transform.column.to(x) : x) + "=" + stringifyValue("values", first[x], parameters, types2, options)
-        );
-      },
-      insert(first, rest, parameters, types2, options) {
-        const columns = rest.length ? rest.flat() : Object.keys(Array.isArray(first) ? first[0] : first);
-        return "(" + escapeIdentifiers(columns, options) + ")values" + valuesBuilder(Array.isArray(first) ? first : [first], parameters, types2, columns, options);
-      }
-    }).map(([x, fn]) => [new RegExp("((?:^|[\\s(])" + x + "(?:$|[\\s(]))(?![\\s\\S]*\\1)", "i"), fn]);
-    serializers = defaultHandlers.serializers;
-    parsers = defaultHandlers.parsers;
-    mergeUserTypes = function(types2) {
-      const user = typeHandlers(types2 || {});
-      return {
-        serializers: Object.assign({}, serializers, user.serializers),
-        parsers: Object.assign({}, parsers, user.parsers)
-      };
-    };
-    escapeIdentifier = function escape(str) {
-      return '"' + str.replace(/"/g, '""').replace(/\./g, '"."') + '"';
-    };
-    inferType = function inferType2(x) {
-      return x instanceof Parameter ? x.type : x instanceof Date ? 1184 : x instanceof Uint8Array ? 17 : x === true || x === false ? 16 : typeof x === "bigint" ? 20 : Array.isArray(x) ? inferType2(x[0]) : 0;
-    };
-    escapeBackslash = /\\/g;
-    escapeQuote = /"/g;
-    arraySerializer = function arraySerializer2(xs, serializer, options, typarray) {
-      if (Array.isArray(xs) === false)
-        return xs;
-      if (!xs.length)
-        return "{}";
-      const first = xs[0];
-      const delimiter = typarray === 1020 ? ";" : ",";
-      if (Array.isArray(first) && !first.type)
-        return "{" + xs.map((x) => arraySerializer2(x, serializer, options, typarray)).join(delimiter) + "}";
-      return "{" + xs.map((x) => {
-        if (x === void 0) {
-          x = options.transform.undefined;
-          if (x === void 0)
-            throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
-        }
-        return x === null ? "null" : '"' + arrayEscape(serializer ? serializer(x.type ? x.value : x) : "" + x) + '"';
-      }).join(delimiter) + "}";
-    };
-    arrayParserState = {
-      i: 0,
-      char: null,
-      str: "",
-      quoted: false,
-      last: 0
-    };
-    arrayParser = function arrayParser2(x, parser, typarray) {
-      arrayParserState.i = arrayParserState.last = 0;
-      return arrayParserLoop(arrayParserState, x, parser, typarray);
-    };
-    toCamel = (x) => {
-      let str = x[0];
-      for (let i = 1; i < x.length; i++)
-        str += x[i] === "_" ? x[++i].toUpperCase() : x[i];
-      return str;
-    };
-    toPascal = (x) => {
-      let str = x[0].toUpperCase();
-      for (let i = 1; i < x.length; i++)
-        str += x[i] === "_" ? x[++i].toUpperCase() : x[i];
-      return str;
-    };
-    toKebab = (x) => x.replace(/_/g, "-");
-    fromCamel = (x) => x.replace(/([A-Z])/g, "_$1").toLowerCase();
-    fromPascal = (x) => (x.slice(0, 1) + x.slice(1).replace(/([A-Z])/g, "_$1")).toLowerCase();
-    fromKebab = (x) => x.replace(/-/g, "_");
-    toCamel.column = { from: toCamel };
-    toCamel.value = { from: createJsonTransform(toCamel) };
-    fromCamel.column = { to: fromCamel };
-    camel = __spreadValues({}, toCamel);
-    camel.column.to = fromCamel;
-    toPascal.column = { from: toPascal };
-    toPascal.value = { from: createJsonTransform(toPascal) };
-    fromPascal.column = { to: fromPascal };
-    pascal = __spreadValues({}, toPascal);
-    pascal.column.to = fromPascal;
-    toKebab.column = { from: toKebab };
-    toKebab.value = { from: createJsonTransform(toKebab) };
-    fromKebab.column = { to: fromKebab };
-    kebab = __spreadValues({}, toKebab);
-    kebab.column.to = fromKebab;
-  }
-});
-
-// node_modules/postgres/src/result.js
-var Result;
-var init_result = __esm({
-  "node_modules/postgres/src/result.js"() {
-    Result = class extends Array {
-      constructor() {
-        super();
-        Object.defineProperties(this, {
-          count: { value: null, writable: true },
-          state: { value: null, writable: true },
-          command: { value: null, writable: true },
-          columns: { value: null, writable: true },
-          statement: { value: null, writable: true }
-        });
-      }
-      static get [Symbol.species]() {
-        return Array;
-      }
-    };
-  }
-});
-
-// node_modules/postgres/src/queue.js
-function Queue(initial = []) {
-  let xs = initial.slice();
-  let index = 0;
-  return {
-    get length() {
-      return xs.length - index;
-    },
-    remove: (x) => {
-      const index2 = xs.indexOf(x);
-      return index2 === -1 ? null : (xs.splice(index2, 1), x);
-    },
-    push: (x) => (xs.push(x), x),
-    shift: () => {
-      const out = xs[index++];
-      if (index === xs.length) {
-        index = 0;
-        xs = [];
-      } else {
-        xs[index - 1] = void 0;
-      }
-      return out;
-    }
-  };
-}
-var queue_default;
-var init_queue = __esm({
-  "node_modules/postgres/src/queue.js"() {
-    queue_default = Queue;
-  }
-});
-
-// node_modules/postgres/src/bytes.js
-function fit(x) {
-  if (buffer.length - b.i < x) {
-    const prev = buffer, length = prev.length;
-    buffer = Buffer.allocUnsafe(length + (length >> 1) + x);
-    prev.copy(buffer);
-  }
-}
-function reset() {
-  b.i = 0;
-  return b;
-}
-var size, buffer, messages, b, bytes_default;
-var init_bytes = __esm({
-  "node_modules/postgres/src/bytes.js"() {
-    size = 256;
-    buffer = Buffer.allocUnsafe(size);
-    messages = "BCcDdEFfHPpQSX".split("").reduce((acc, x) => {
-      const v = x.charCodeAt(0);
-      acc[x] = () => {
-        buffer[0] = v;
-        b.i = 5;
-        return b;
-      };
-      return acc;
-    }, {});
-    b = Object.assign(reset, messages, {
-      N: String.fromCharCode(0),
-      i: 0,
-      inc(x) {
-        b.i += x;
-        return b;
-      },
-      str(x) {
-        const length = Buffer.byteLength(x);
-        fit(length);
-        b.i += buffer.write(x, b.i, length, "utf8");
-        return b;
-      },
-      i16(x) {
-        fit(2);
-        buffer.writeUInt16BE(x, b.i);
-        b.i += 2;
-        return b;
-      },
-      i32(x, i) {
-        if (i || i === 0) {
-          buffer.writeUInt32BE(x, i);
-          return b;
-        }
-        fit(4);
-        buffer.writeUInt32BE(x, b.i);
-        b.i += 4;
-        return b;
-      },
-      z(x) {
-        fit(x);
-        buffer.fill(0, b.i, b.i + x);
-        b.i += x;
-        return b;
-      },
-      raw(x) {
-        buffer = Buffer.concat([buffer.subarray(0, b.i), x]);
-        b.i = buffer.length;
-        return b;
-      },
-      end(at = 1) {
-        buffer.writeUInt32BE(b.i - at, at);
-        const out = buffer.subarray(0, b.i);
-        b.i = 0;
-        buffer = Buffer.allocUnsafe(size);
-        return out;
-      }
-    });
-    bytes_default = b;
-  }
-});
-function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose = noop } = {}) {
-  const {
-    sslnegotiation,
-    ssl,
-    max,
-    user,
-    host,
-    port,
-    database,
-    parsers: parsers2,
-    transform,
-    onnotice,
-    onnotify,
-    onparameter,
-    max_pipeline,
-    keep_alive,
-    backoff: backoff2,
-    target_session_attrs
-  } = options;
-  const sent = queue_default(), id = uid++, backend = { pid: null, secret: null }, idleTimer = timer(end, options.idle_timeout), lifeTimer = timer(end, options.max_lifetime), connectTimer = timer(connectTimedOut, options.connect_timeout);
-  let socket = null, cancelMessage, errorResponse = null, result = new Result(), incoming = Buffer.alloc(0), needsTypes = options.fetch_types, backendParameters = {}, statements = {}, statementId = Math.random().toString(36).slice(2), statementCount = 1, closedTime = 0, remaining = 0, hostIndex = 0, retries = 0, length = 0, delay = 0, rows = 0, serverSignature = null, nextWriteTimer = null, terminated = false, incomings = null, results = null, initial = null, ending = null, stream = null, chunk = null, ended = null, nonce = null, query = null, final = null;
-  const connection2 = {
-    queue: queues.closed,
-    idleTimer,
-    connect(query2) {
-      initial = query2;
-      reconnect();
-    },
-    terminate,
-    execute,
-    cancel,
-    end,
-    count: 0,
-    id
-  };
-  queues.closed && queues.closed.push(connection2);
-  return connection2;
-  function createSocket() {
-    return __async(this, null, function* () {
-      let x;
-      try {
-        x = options.socket ? yield Promise.resolve(options.socket(options)) : new net.Socket();
-      } catch (e) {
-        error(e);
-        return;
-      }
-      x.on("error", error);
-      x.on("close", closed);
-      x.on("drain", drain);
-      return x;
-    });
-  }
-  function cancel(_0, _1, _2) {
-    return __async(this, arguments, function* ({ pid, secret }, resolve3, reject) {
-      try {
-        cancelMessage = bytes_default().i32(16).i32(80877102).i32(pid).i32(secret).end(16);
-        yield connect();
-        socket.once("error", reject);
-        socket.once("close", resolve3);
-      } catch (error2) {
-        reject(error2);
-      }
-    });
-  }
-  function execute(q) {
-    if (terminated)
-      return queryError(q, Errors.connection("CONNECTION_DESTROYED", options));
-    if (stream)
-      return queryError(q, Errors.generic("COPY_IN_PROGRESS", "You cannot execute queries during copy"));
-    if (q.cancelled)
-      return;
-    try {
-      q.state = backend;
-      query ? sent.push(q) : (query = q, query.active = true);
-      build(q);
-      return write(toBuffer(q)) && !q.describeFirst && !q.cursorFn && sent.length < max_pipeline && (!q.options.onexecute || q.options.onexecute(connection2));
-    } catch (error2) {
-      sent.length === 0 && write(Sync);
-      errored(error2);
-      return true;
-    }
-  }
-  function toBuffer(q) {
-    if (q.parameters.length >= 65534)
-      throw Errors.generic("MAX_PARAMETERS_EXCEEDED", "Max number of parameters (65534) exceeded");
-    return q.options.simple ? bytes_default().Q().str(q.statement.string + bytes_default.N).end() : q.describeFirst ? Buffer.concat([describe(q), Flush]) : q.prepare ? q.prepared ? prepared(q) : Buffer.concat([describe(q), prepared(q)]) : unnamed(q);
-  }
-  function describe(q) {
-    return Buffer.concat([
-      Parse(q.statement.string, q.parameters, q.statement.types, q.statement.name),
-      Describe("S", q.statement.name)
-    ]);
-  }
-  function prepared(q) {
-    return Buffer.concat([
-      Bind(q.parameters, q.statement.types, q.statement.name, q.cursorName),
-      q.cursorFn ? Execute("", q.cursorRows) : ExecuteUnnamed
-    ]);
-  }
-  function unnamed(q) {
-    return Buffer.concat([
-      Parse(q.statement.string, q.parameters, q.statement.types),
-      DescribeUnnamed,
-      prepared(q)
-    ]);
-  }
-  function build(q) {
-    const parameters = [], types2 = [];
-    const string = stringify(q, q.strings[0], q.args[0], parameters, types2, options);
-    !q.tagged && q.args.forEach((x) => handleValue(x, parameters, types2, options));
-    q.prepare = options.prepare && ("prepare" in q.options ? q.options.prepare : true);
-    q.string = string;
-    q.signature = q.prepare && types2 + string;
-    q.onlyDescribe && delete statements[q.signature];
-    q.parameters = q.parameters || parameters;
-    q.prepared = q.prepare && q.signature in statements;
-    q.describeFirst = q.onlyDescribe || parameters.length && !q.prepared;
-    q.statement = q.prepared ? statements[q.signature] : { string, types: types2, name: q.prepare ? statementId + statementCount++ : "" };
-    typeof options.debug === "function" && options.debug(id, string, parameters, types2);
-  }
-  function write(x, fn) {
-    chunk = chunk ? Buffer.concat([chunk, x]) : Buffer.from(x);
-    if (chunk.length >= 1024)
-      return nextWrite(fn);
-    nextWriteTimer === null && (nextWriteTimer = setImmediate(nextWrite));
-    return true;
-  }
-  function nextWrite(fn) {
-    const x = socket.write(chunk, fn);
-    nextWriteTimer !== null && clearImmediate(nextWriteTimer);
-    chunk = nextWriteTimer = null;
-    return x;
-  }
-  function connectTimedOut() {
-    errored(Errors.connection("CONNECT_TIMEOUT", options, socket));
-    socket.destroy();
-  }
-  function secure() {
-    return __async(this, null, function* () {
-      if (sslnegotiation !== "direct") {
-        write(SSLRequest);
-        const canSSL = yield new Promise((r) => socket.once("data", (x) => r(x[0] === 83)));
-        if (!canSSL && ssl === "prefer")
-          return connected();
-      }
-      const options2 = {
-        socket,
-        servername: net.isIP(socket.host) ? void 0 : socket.host
-      };
-      if (sslnegotiation === "direct")
-        options2.ALPNProtocols = ["postgresql"];
-      if (ssl === "require" || ssl === "allow" || ssl === "prefer")
-        options2.rejectUnauthorized = false;
-      else if (typeof ssl === "object")
-        Object.assign(options2, ssl);
-      socket.removeAllListeners();
-      socket = tls.connect(options2);
-      socket.on("secureConnect", connected);
-      socket.on("error", error);
-      socket.on("close", closed);
-      socket.on("drain", drain);
-    });
-  }
-  function drain() {
-    !query && onopen(connection2);
-  }
-  function data(x) {
-    if (incomings) {
-      incomings.push(x);
-      remaining -= x.length;
-      if (remaining > 0)
-        return;
-    }
-    incoming = incomings ? Buffer.concat(incomings, length - remaining) : incoming.length === 0 ? x : Buffer.concat([incoming, x], incoming.length + x.length);
-    while (incoming.length > 4) {
-      length = incoming.readUInt32BE(1);
-      if (length >= incoming.length) {
-        remaining = length - incoming.length;
-        incomings = [incoming];
-        break;
-      }
-      try {
-        handle(incoming.subarray(0, length + 1));
-      } catch (e) {
-        query && (query.cursorFn || query.describeFirst) && write(Sync);
-        errored(e);
-      }
-      incoming = incoming.subarray(length + 1);
-      remaining = 0;
-      incomings = null;
-    }
-  }
-  function connect() {
-    return __async(this, null, function* () {
-      terminated = false;
-      backendParameters = {};
-      socket || (socket = yield createSocket());
-      if (!socket)
-        return;
-      connectTimer.start();
-      if (options.socket)
-        return ssl ? secure() : connected();
-      socket.on("connect", ssl ? secure : connected);
-      if (options.path)
-        return socket.connect(options.path);
-      socket.ssl = ssl;
-      socket.connect(port[hostIndex], host[hostIndex]);
-      socket.host = host[hostIndex];
-      socket.port = port[hostIndex];
-      hostIndex = (hostIndex + 1) % port.length;
-    });
-  }
-  function reconnect() {
-    setTimeout(connect, closedTime ? Math.max(0, closedTime + delay - performance$1.now()) : 0);
-  }
-  function connected() {
-    try {
-      statements = {};
-      needsTypes = options.fetch_types;
-      statementId = Math.random().toString(36).slice(2);
-      statementCount = 1;
-      lifeTimer.start();
-      socket.on("data", data);
-      keep_alive && socket.setKeepAlive && socket.setKeepAlive(true, 1e3 * keep_alive);
-      const s = StartupMessage();
-      write(s);
-    } catch (err) {
-      error(err);
-    }
-  }
-  function error(err) {
-    if (connection2.queue === queues.connecting && options.host[retries + 1])
-      return;
-    errored(err);
-    while (sent.length)
-      queryError(sent.shift(), err);
-  }
-  function errored(err) {
-    stream && (stream.destroy(err), stream = null);
-    query && queryError(query, err);
-    initial && (queryError(initial, err), initial = null);
-  }
-  function queryError(query2, err) {
-    if (query2.reserve)
-      return query2.reject(err);
-    if (!err || typeof err !== "object")
-      err = new Error(err);
-    "query" in err || "parameters" in err || Object.defineProperties(err, {
-      stack: { value: err.stack + query2.origin.replace(/.*\n/, "\n"), enumerable: options.debug },
-      query: { value: query2.string, enumerable: options.debug },
-      parameters: { value: query2.parameters, enumerable: options.debug },
-      args: { value: query2.args, enumerable: options.debug },
-      types: { value: query2.statement && query2.statement.types, enumerable: options.debug }
-    });
-    query2.reject(err);
-  }
-  function end() {
-    return ending || (!connection2.reserved && onend(connection2), !connection2.reserved && !initial && !query && sent.length === 0 ? (terminate(), new Promise((r) => socket && socket.readyState !== "closed" ? socket.once("close", r) : r())) : ending = new Promise((r) => ended = r));
-  }
-  function terminate() {
-    terminated = true;
-    if (stream || query || initial || sent.length)
-      error(Errors.connection("CONNECTION_DESTROYED", options));
-    clearImmediate(nextWriteTimer);
-    if (socket) {
-      socket.removeListener("data", data);
-      socket.removeListener("connect", connected);
-      socket.readyState === "open" && socket.end(bytes_default().X().end());
-    }
-    ended && (ended(), ending = ended = null);
-  }
-  function closed(hadError) {
-    return __async(this, null, function* () {
-      incoming = Buffer.alloc(0);
-      remaining = 0;
-      incomings = null;
-      clearImmediate(nextWriteTimer);
-      socket.removeListener("data", data);
-      socket.removeListener("connect", connected);
-      idleTimer.cancel();
-      lifeTimer.cancel();
-      connectTimer.cancel();
-      socket.removeAllListeners();
-      socket = null;
-      if (initial)
-        return reconnect();
-      !hadError && (query || sent.length) && error(Errors.connection("CONNECTION_CLOSED", options, socket));
-      closedTime = performance$1.now();
-      hadError && options.shared.retries++;
-      delay = (typeof backoff2 === "function" ? backoff2(options.shared.retries) : backoff2) * 1e3;
-      onclose(connection2, Errors.connection("CONNECTION_CLOSED", options, socket));
-    });
-  }
-  function handle(xs, x = xs[0]) {
-    (x === 68 ? DataRow : (
-      // D
-      x === 100 ? CopyData : (
-        // d
-        x === 65 ? NotificationResponse : (
-          // A
-          x === 83 ? ParameterStatus : (
-            // S
-            x === 90 ? ReadyForQuery : (
-              // Z
-              x === 67 ? CommandComplete : (
-                // C
-                x === 50 ? BindComplete : (
-                  // 2
-                  x === 49 ? ParseComplete : (
-                    // 1
-                    x === 116 ? ParameterDescription : (
-                      // t
-                      x === 84 ? RowDescription : (
-                        // T
-                        x === 82 ? Authentication : (
-                          // R
-                          x === 110 ? NoData : (
-                            // n
-                            x === 75 ? BackendKeyData : (
-                              // K
-                              x === 69 ? ErrorResponse : (
-                                // E
-                                x === 115 ? PortalSuspended : (
-                                  // s
-                                  x === 51 ? CloseComplete : (
-                                    // 3
-                                    x === 71 ? CopyInResponse : (
-                                      // G
-                                      x === 78 ? NoticeResponse : (
-                                        // N
-                                        x === 72 ? CopyOutResponse : (
-                                          // H
-                                          x === 99 ? CopyDone : (
-                                            // c
-                                            x === 73 ? EmptyQueryResponse : (
-                                              // I
-                                              x === 86 ? FunctionCallResponse : (
-                                                // V
-                                                x === 118 ? NegotiateProtocolVersion : (
-                                                  // v
-                                                  x === 87 ? CopyBothResponse : (
-                                                    // W
-                                                    /* c8 ignore next */
-                                                    UnknownMessage
-                                                  )
-                                                )
-                                              )
-                                            )
-                                          )
-                                        )
-                                      )
-                                    )
-                                  )
-                                )
-                              )
-                            )
-                          )
-                        )
-                      )
-                    )
-                  )
-                )
-              )
-            )
-          )
-        )
-      )
-    ))(xs);
-  }
-  function DataRow(x) {
-    let index = 7;
-    let length2;
-    let column;
-    let value;
-    const row = query.isRaw ? new Array(query.statement.columns.length) : {};
-    for (let i = 0; i < query.statement.columns.length; i++) {
-      column = query.statement.columns[i];
-      length2 = x.readInt32BE(index);
-      index += 4;
-      value = length2 === -1 ? null : query.isRaw === true ? x.subarray(index, index += length2) : column.parser === void 0 ? x.toString("utf8", index, index += length2) : column.parser.array === true ? column.parser(x.toString("utf8", index + 1, index += length2)) : column.parser(x.toString("utf8", index, index += length2));
-      query.isRaw ? row[i] = query.isRaw === true ? value : transform.value.from ? transform.value.from(value, column) : value : row[column.name] = transform.value.from ? transform.value.from(value, column) : value;
-    }
-    query.forEachFn ? query.forEachFn(transform.row.from ? transform.row.from(row) : row, result) : result[rows++] = transform.row.from ? transform.row.from(row) : row;
-  }
-  function ParameterStatus(x) {
-    const [k, v] = x.toString("utf8", 5, x.length - 1).split(bytes_default.N);
-    backendParameters[k] = v;
-    if (options.parameters[k] !== v) {
-      options.parameters[k] = v;
-      onparameter && onparameter(k, v);
-    }
-  }
-  function ReadyForQuery(x) {
-    if (query) {
-      if (errorResponse) {
-        query.retried ? errored(query.retried) : query.prepared && retryRoutines.has(errorResponse.routine) ? retry(query, errorResponse) : errored(errorResponse);
-      } else {
-        query.resolve(results || result);
-      }
-    } else if (errorResponse) {
-      errored(errorResponse);
-    }
-    query = results = errorResponse = null;
-    result = new Result();
-    connectTimer.cancel();
-    if (initial) {
-      if (target_session_attrs) {
-        if (!backendParameters.in_hot_standby || !backendParameters.default_transaction_read_only)
-          return fetchState();
-        else if (tryNext(target_session_attrs, backendParameters))
-          return terminate();
-      }
-      if (needsTypes) {
-        initial.reserve && (initial = null);
-        return fetchArrayTypes();
-      }
-      initial && !initial.reserve && execute(initial);
-      options.shared.retries = retries = 0;
-      initial = null;
-      return;
-    }
-    while (sent.length && (query = sent.shift()) && (query.active = true, query.cancelled))
-      Connection(options).cancel(query.state, query.cancelled.resolve, query.cancelled.reject);
-    if (query)
-      return;
-    connection2.reserved ? !connection2.reserved.release && x[5] === 73 ? ending ? terminate() : (connection2.reserved = null, onopen(connection2)) : connection2.reserved() : ending ? terminate() : onopen(connection2);
-  }
-  function CommandComplete(x) {
-    rows = 0;
-    for (let i = x.length - 1; i > 0; i--) {
-      if (x[i] === 32 && x[i + 1] < 58 && result.count === null)
-        result.count = +x.toString("utf8", i + 1, x.length - 1);
-      if (x[i - 1] >= 65) {
-        result.command = x.toString("utf8", 5, i);
-        result.state = backend;
-        break;
-      }
-    }
-    final && (final(), final = null);
-    if (result.command === "BEGIN" && max !== 1 && !connection2.reserved)
-      return errored(Errors.generic("UNSAFE_TRANSACTION", "Only use sql.begin, sql.reserved or max: 1"));
-    if (query.options.simple)
-      return BindComplete();
-    if (query.cursorFn) {
-      result.count && query.cursorFn(result);
-      write(Sync);
-    }
-  }
-  function ParseComplete() {
-    query.parsing = false;
-  }
-  function BindComplete() {
-    !result.statement && (result.statement = query.statement);
-    result.columns = query.statement.columns;
-  }
-  function ParameterDescription(x) {
-    const length2 = x.readUInt16BE(5);
-    for (let i = 0; i < length2; ++i)
-      !query.statement.types[i] && (query.statement.types[i] = x.readUInt32BE(7 + i * 4));
-    query.prepare && (statements[query.signature] = query.statement);
-    query.describeFirst && !query.onlyDescribe && (write(prepared(query)), query.describeFirst = false);
-  }
-  function RowDescription(x) {
-    if (result.command) {
-      results = results || [result];
-      results.push(result = new Result());
-      result.count = null;
-      query.statement.columns = null;
-    }
-    const length2 = x.readUInt16BE(5);
-    let index = 7;
-    let start;
-    query.statement.columns = Array(length2);
-    for (let i = 0; i < length2; ++i) {
-      start = index;
-      while (x[index++] !== 0) ;
-      const table = x.readUInt32BE(index);
-      const number = x.readUInt16BE(index + 4);
-      const type = x.readUInt32BE(index + 6);
-      query.statement.columns[i] = {
-        name: transform.column.from ? transform.column.from(x.toString("utf8", start, index - 1)) : x.toString("utf8", start, index - 1),
-        parser: parsers2[type],
-        table,
-        number,
-        type
-      };
-      index += 18;
-    }
-    result.statement = query.statement;
-    if (query.onlyDescribe)
-      return query.resolve(query.statement), write(Sync);
-  }
-  function Authentication(_0) {
-    return __async(this, arguments, function* (x, type = x.readUInt32BE(5)) {
-      (type === 3 ? AuthenticationCleartextPassword : type === 5 ? AuthenticationMD5Password : type === 10 ? SASL : type === 11 ? SASLContinue : type === 12 ? SASLFinal : type !== 0 ? UnknownAuth : noop)(x, type);
-    });
-  }
-  function AuthenticationCleartextPassword() {
-    return __async(this, null, function* () {
-      const payload = yield Pass();
-      write(
-        bytes_default().p().str(payload).z(1).end()
-      );
-    });
-  }
-  function AuthenticationMD5Password(x) {
-    return __async(this, null, function* () {
-      const payload = "md5" + (yield md5(
-        Buffer.concat([
-          Buffer.from(yield md5((yield Pass()) + user)),
-          x.subarray(9)
-        ])
-      ));
-      write(
-        bytes_default().p().str(payload).z(1).end()
-      );
-    });
-  }
-  function SASL() {
-    return __async(this, null, function* () {
-      nonce = (yield crypto.randomBytes(18)).toString("base64");
-      bytes_default().p().str("SCRAM-SHA-256" + bytes_default.N);
-      const i = bytes_default.i;
-      write(bytes_default.inc(4).str("n,,n=*,r=" + nonce).i32(bytes_default.i - i - 4, i).end());
-    });
-  }
-  function SASLContinue(x) {
-    return __async(this, null, function* () {
-      const res = x.toString("utf8", 9).split(",").reduce((acc, x2) => (acc[x2[0]] = x2.slice(2), acc), {});
-      const saltedPassword = yield crypto.pbkdf2Sync(
-        yield Pass(),
-        Buffer.from(res.s, "base64"),
-        parseInt(res.i),
-        32,
-        "sha256"
-      );
-      const clientKey = yield hmac(saltedPassword, "Client Key");
-      const auth = "n=*,r=" + nonce + ",r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
-      serverSignature = (yield hmac(yield hmac(saltedPassword, "Server Key"), auth)).toString("base64");
-      const payload = "c=biws,r=" + res.r + ",p=" + xor(
-        clientKey,
-        Buffer.from(yield hmac(yield sha256(clientKey), auth))
-      ).toString("base64");
-      write(
-        bytes_default().p().str(payload).end()
-      );
-    });
-  }
-  function SASLFinal(x) {
-    if (x.toString("utf8", 9).split(bytes_default.N, 1)[0].slice(2) === serverSignature)
-      return;
-    errored(Errors.generic("SASL_SIGNATURE_MISMATCH", "The server did not return the correct signature"));
-    socket.destroy();
-  }
-  function Pass() {
-    return Promise.resolve(
-      typeof options.pass === "function" ? options.pass() : options.pass
-    );
-  }
-  function NoData() {
-    result.statement = query.statement;
-    result.statement.columns = [];
-    if (query.onlyDescribe)
-      return query.resolve(query.statement), write(Sync);
-  }
-  function BackendKeyData(x) {
-    backend.pid = x.readUInt32BE(5);
-    backend.secret = x.readUInt32BE(9);
-  }
-  function fetchArrayTypes() {
-    return __async(this, null, function* () {
-      needsTypes = false;
-      const types2 = yield new Query([`
-      select b.oid, b.typarray
-      from pg_catalog.pg_type a
-      left join pg_catalog.pg_type b on b.oid = a.typelem
-      where a.typcategory = 'A'
-      group by b.oid, b.typarray
-      order by b.oid
-    `], [], execute);
-      types2.forEach(({ oid, typarray }) => addArrayType(oid, typarray));
-    });
-  }
-  function addArrayType(oid, typarray) {
-    if (!!options.parsers[typarray] && !!options.serializers[typarray]) return;
-    const parser = options.parsers[oid];
-    options.shared.typeArrayMap[oid] = typarray;
-    options.parsers[typarray] = (xs) => arrayParser(xs, parser, typarray);
-    options.parsers[typarray].array = true;
-    options.serializers[typarray] = (xs) => arraySerializer(xs, options.serializers[oid], options, typarray);
-  }
-  function tryNext(x, xs) {
-    return x === "read-write" && xs.default_transaction_read_only === "on" || x === "read-only" && xs.default_transaction_read_only === "off" || x === "primary" && xs.in_hot_standby === "on" || x === "standby" && xs.in_hot_standby === "off" || x === "prefer-standby" && xs.in_hot_standby === "off" && options.host[retries];
-  }
-  function fetchState() {
-    const query2 = new Query([`
-      show transaction_read_only;
-      select pg_catalog.pg_is_in_recovery()
-    `], [], execute, null, { simple: true });
-    query2.resolve = ([[a], [b2]]) => {
-      backendParameters.default_transaction_read_only = a.transaction_read_only;
-      backendParameters.in_hot_standby = b2.pg_is_in_recovery ? "on" : "off";
-    };
-    query2.execute();
-  }
-  function ErrorResponse(x) {
-    if (query) {
-      (query.cursorFn || query.describeFirst) && write(Sync);
-      errorResponse = Errors.postgres(parseError(x));
-    } else {
-      errored(Errors.postgres(parseError(x)));
-    }
-  }
-  function retry(q, error2) {
-    delete statements[q.signature];
-    q.retried = error2;
-    execute(q);
-  }
-  function NotificationResponse(x) {
-    if (!onnotify)
-      return;
-    let index = 9;
-    while (x[index++] !== 0) ;
-    onnotify(
-      x.toString("utf8", 9, index - 1),
-      x.toString("utf8", index, x.length - 1)
-    );
-  }
-  function PortalSuspended() {
-    return __async(this, null, function* () {
-      try {
-        const x = yield Promise.resolve(query.cursorFn(result));
-        rows = 0;
-        x === CLOSE ? write(Close(query.portal)) : (result = new Result(), write(Execute("", query.cursorRows)));
-      } catch (err) {
-        write(Sync);
-        query.reject(err);
-      }
-    });
-  }
-  function CloseComplete() {
-    result.count && query.cursorFn(result);
-    query.resolve(result);
-  }
-  function CopyInResponse() {
-    stream = new Stream.Writable({
-      autoDestroy: true,
-      write(chunk2, encoding, callback) {
-        socket.write(bytes_default().d().raw(chunk2).end(), callback);
-      },
-      destroy(error2, callback) {
-        callback(error2);
-        socket.write(bytes_default().f().str(error2 + bytes_default.N).end());
-        stream = null;
-      },
-      final(callback) {
-        socket.write(bytes_default().c().end());
-        final = callback;
-        stream = null;
-      }
-    });
-    query.resolve(stream);
-  }
-  function CopyOutResponse() {
-    stream = new Stream.Readable({
-      read() {
-        socket.resume();
-      }
-    });
-    query.resolve(stream);
-  }
-  function CopyBothResponse() {
-    stream = new Stream.Duplex({
-      autoDestroy: true,
-      read() {
-        socket.resume();
-      },
-      /* c8 ignore next 11 */
-      write(chunk2, encoding, callback) {
-        socket.write(bytes_default().d().raw(chunk2).end(), callback);
-      },
-      destroy(error2, callback) {
-        callback(error2);
-        socket.write(bytes_default().f().str(error2 + bytes_default.N).end());
-        stream = null;
-      },
-      final(callback) {
-        socket.write(bytes_default().c().end());
-        final = callback;
-      }
-    });
-    query.resolve(stream);
-  }
-  function CopyData(x) {
-    stream && (stream.push(x.subarray(5)) || socket.pause());
-  }
-  function CopyDone() {
-    stream && stream.push(null);
-    stream = null;
-  }
-  function NoticeResponse(x) {
-    onnotice ? onnotice(parseError(x)) : console.log(parseError(x));
-  }
-  function EmptyQueryResponse() {
-  }
-  function FunctionCallResponse() {
-    errored(Errors.notSupported("FunctionCallResponse"));
-  }
-  function NegotiateProtocolVersion() {
-    errored(Errors.notSupported("NegotiateProtocolVersion"));
-  }
-  function UnknownMessage(x) {
-    console.error("Postgres.js : Unknown Message:", x[0]);
-  }
-  function UnknownAuth(x, type) {
-    console.error("Postgres.js : Unknown Auth:", type);
-  }
-  function Bind(parameters, types2, statement = "", portal = "") {
-    let prev, type;
-    bytes_default().B().str(portal + bytes_default.N).str(statement + bytes_default.N).i16(0).i16(parameters.length);
-    parameters.forEach((x, i) => {
-      if (x === null)
-        return bytes_default.i32(4294967295);
-      type = types2[i];
-      parameters[i] = x = type in options.serializers ? options.serializers[type](x) : "" + x;
-      prev = bytes_default.i;
-      bytes_default.inc(4).str(x).i32(bytes_default.i - prev - 4, prev);
-    });
-    bytes_default.i16(0);
-    return bytes_default.end();
-  }
-  function Parse(str, parameters, types2, name = "") {
-    bytes_default().P().str(name + bytes_default.N).str(str + bytes_default.N).i16(parameters.length);
-    parameters.forEach((x, i) => bytes_default.i32(types2[i] || 0));
-    return bytes_default.end();
-  }
-  function Describe(x, name = "") {
-    return bytes_default().D().str(x).str(name + bytes_default.N).end();
-  }
-  function Execute(portal = "", rows2 = 0) {
-    return Buffer.concat([
-      bytes_default().E().str(portal + bytes_default.N).i32(rows2).end(),
-      Flush
-    ]);
-  }
-  function Close(portal = "") {
-    return Buffer.concat([
-      bytes_default().C().str("P").str(portal + bytes_default.N).end(),
-      bytes_default().S().end()
-    ]);
-  }
-  function StartupMessage() {
-    return cancelMessage || bytes_default().inc(4).i16(3).z(2).str(
-      Object.entries(Object.assign(
-        {
-          user,
-          database,
-          client_encoding: "UTF8"
-        },
-        options.connection
-      )).filter(([, v]) => v).map(([k, v]) => k + bytes_default.N + v).join(bytes_default.N)
-    ).z(2).end(0);
-  }
-}
-function parseError(x) {
-  const error = {};
-  let start = 5;
-  for (let i = 5; i < x.length - 1; i++) {
-    if (x[i] === 0) {
-      error[errorFields[x[start]]] = x.toString("utf8", start + 1, i);
-      start = i + 1;
-    }
-  }
-  return error;
-}
-function md5(x) {
-  return crypto.createHash("md5").update(x).digest("hex");
-}
-function hmac(key, x) {
-  return crypto.createHmac("sha256", key).update(x).digest();
-}
-function sha256(x) {
-  return crypto.createHash("sha256").update(x).digest();
-}
-function xor(a, b2) {
-  const length = Math.max(a.length, b2.length);
-  const buffer2 = Buffer.allocUnsafe(length);
-  for (let i = 0; i < length; i++)
-    buffer2[i] = a[i] ^ b2[i];
-  return buffer2;
-}
-function timer(fn, seconds) {
-  seconds = typeof seconds === "function" ? seconds() : seconds;
-  if (!seconds)
-    return { cancel: noop, start: noop };
-  let timer2;
-  return {
-    cancel() {
-      timer2 && (clearTimeout(timer2), timer2 = null);
-    },
-    start() {
-      timer2 && clearTimeout(timer2);
-      timer2 = setTimeout(done, seconds * 1e3, arguments);
-    }
-  };
-  function done(args) {
-    fn.apply(null, args);
-    timer2 = null;
-  }
-}
-var connection_default, uid, Sync, Flush, SSLRequest, ExecuteUnnamed, DescribeUnnamed, noop, retryRoutines, errorFields;
-var init_connection = __esm({
-  "node_modules/postgres/src/connection.js"() {
-    init_types();
-    init_errors();
-    init_result();
-    init_queue();
-    init_query();
-    init_bytes();
-    connection_default = Connection;
-    uid = 1;
-    Sync = bytes_default().S().end();
-    Flush = bytes_default().H().end();
-    SSLRequest = bytes_default().i32(8).i32(80877103).end(8);
-    ExecuteUnnamed = Buffer.concat([bytes_default().E().str(bytes_default.N).i32(0).end(), Sync]);
-    DescribeUnnamed = bytes_default().D().str("S").str(bytes_default.N).end();
-    noop = () => {
-    };
-    retryRoutines = /* @__PURE__ */ new Set([
-      "FetchPreparedStatement",
-      "RevalidateCachedQuery",
-      "transformAssignedExpr"
-    ]);
-    errorFields = {
-      83: "severity_local",
-      // S
-      86: "severity",
-      // V
-      67: "code",
-      // C
-      77: "message",
-      // M
-      68: "detail",
-      // D
-      72: "hint",
-      // H
-      80: "position",
-      // P
-      112: "internal_position",
-      // p
-      113: "internal_query",
-      // q
-      87: "where",
-      // W
-      115: "schema_name",
-      // s
-      116: "table_name",
-      // t
-      99: "column_name",
-      // c
-      100: "data type_name",
-      // d
-      110: "constraint_name",
-      // n
-      70: "file",
-      // F
-      76: "line",
-      // L
-      82: "routine"
-      // R
-    };
-  }
-});
-
-// node_modules/postgres/src/subscribe.js
-function Subscribe(postgres2, options) {
-  const subscribers = /* @__PURE__ */ new Map(), slot = "postgresjs_" + Math.random().toString(36).slice(2), state = {};
-  let connection2, stream, ended = false;
-  const sql = subscribe.sql = postgres2(__spreadProps(__spreadValues({}, options), {
-    transform: { column: {}, value: {}, row: {} },
-    max: 1,
-    fetch_types: false,
-    idle_timeout: null,
-    max_lifetime: null,
-    connection: __spreadProps(__spreadValues({}, options.connection), {
-      replication: "database"
-    }),
-    onclose: function() {
-      return __async(this, null, function* () {
-        if (ended)
-          return;
-        stream = null;
-        state.pid = state.secret = void 0;
-        connected(yield init(sql, slot, options.publications));
-        subscribers.forEach((event) => event.forEach(({ onsubscribe }) => onsubscribe()));
-      });
-    },
-    no_subscribe: true
-  }));
-  const end = sql.end, close = sql.close;
-  sql.end = () => __async(null, null, function* () {
-    ended = true;
-    stream && (yield new Promise((r) => (stream.once("close", r), stream.end())));
-    return end();
-  });
-  sql.close = () => __async(null, null, function* () {
-    stream && (yield new Promise((r) => (stream.once("close", r), stream.end())));
-    return close();
-  });
-  return subscribe;
-  function subscribe(_0, _1) {
-    return __async(this, arguments, function* (event, fn, onsubscribe = noop2, onerror = noop2) {
-      event = parseEvent(event);
-      if (!connection2)
-        connection2 = init(sql, slot, options.publications);
-      const subscriber = { fn, onsubscribe };
-      const fns = subscribers.has(event) ? subscribers.get(event).add(subscriber) : subscribers.set(event, /* @__PURE__ */ new Set([subscriber])).get(event);
-      const unsubscribe = () => {
-        fns.delete(subscriber);
-        fns.size === 0 && subscribers.delete(event);
-      };
-      return connection2.then((x) => {
-        connected(x);
-        onsubscribe();
-        stream && stream.on("error", onerror);
-        return { unsubscribe, state, sql };
-      });
-    });
-  }
-  function connected(x) {
-    stream = x.stream;
-    state.pid = x.state.pid;
-    state.secret = x.state.secret;
-  }
-  function init(sql2, slot2, publications) {
-    return __async(this, null, function* () {
-      if (!publications)
-        throw new Error("Missing publication names");
-      const xs = yield sql2.unsafe(
-        `CREATE_REPLICATION_SLOT ${slot2} TEMPORARY LOGICAL pgoutput NOEXPORT_SNAPSHOT`
-      );
-      const [x] = xs;
-      const stream2 = yield sql2.unsafe(
-        `START_REPLICATION SLOT ${slot2} LOGICAL ${x.consistent_point} (proto_version '1', publication_names '${publications}')`
-      ).writable();
-      const state2 = {
-        lsn: Buffer.concat(x.consistent_point.split("/").map((x2) => Buffer.from(("00000000" + x2).slice(-8), "hex")))
-      };
-      stream2.on("data", data);
-      stream2.on("error", error);
-      stream2.on("close", sql2.close);
-      return { stream: stream2, state: xs.state };
-      function error(e) {
-        console.error("Unexpected error during logical streaming - reconnecting", e);
-      }
-      function data(x2) {
-        if (x2[0] === 119) {
-          parse(x2.subarray(25), state2, sql2.options.parsers, handle, options.transform);
-        } else if (x2[0] === 107 && x2[17]) {
-          state2.lsn = x2.subarray(1, 9);
-          pong();
-        }
-      }
-      function handle(a, b2) {
-        const path = b2.relation.schema + "." + b2.relation.table;
-        call("*", a, b2);
-        call("*:" + path, a, b2);
-        b2.relation.keys.length && call("*:" + path + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
-        call(b2.command, a, b2);
-        call(b2.command + ":" + path, a, b2);
-        b2.relation.keys.length && call(b2.command + ":" + path + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
-      }
-      function pong() {
-        const x2 = Buffer.alloc(34);
-        x2[0] = "r".charCodeAt(0);
-        x2.fill(state2.lsn, 1);
-        x2.writeBigInt64BE(BigInt(Date.now() - Date.UTC(2e3, 0, 1)) * BigInt(1e3), 25);
-        stream2.write(x2);
-      }
-    });
-  }
-  function call(x, a, b2) {
-    subscribers.has(x) && subscribers.get(x).forEach(({ fn }) => fn(a, b2, x));
-  }
-}
-function Time(x) {
-  return new Date(Date.UTC(2e3, 0, 1) + Number(x / BigInt(1e3)));
-}
-function parse(x, state, parsers2, handle, transform) {
-  const char = (acc, [k, v]) => (acc[k.charCodeAt(0)] = v, acc);
-  Object.entries({
-    R: (x2) => {
-      let i = 1;
-      const r = state[x2.readUInt32BE(i)] = {
-        schema: x2.toString("utf8", i += 4, i = x2.indexOf(0, i)) || "pg_catalog",
-        table: x2.toString("utf8", i + 1, i = x2.indexOf(0, i + 1)),
-        columns: Array(x2.readUInt16BE(i += 2)),
-        keys: []
-      };
-      i += 2;
-      let columnIndex = 0, column;
-      while (i < x2.length) {
-        column = r.columns[columnIndex++] = {
-          key: x2[i++],
-          name: transform.column.from ? transform.column.from(x2.toString("utf8", i, i = x2.indexOf(0, i))) : x2.toString("utf8", i, i = x2.indexOf(0, i)),
-          type: x2.readUInt32BE(i += 1),
-          parser: parsers2[x2.readUInt32BE(i)],
-          atttypmod: x2.readUInt32BE(i += 4)
-        };
-        column.key && r.keys.push(column);
-        i += 4;
-      }
-    },
-    Y: () => {
-    },
-    // Type
-    O: () => {
-    },
-    // Origin
-    B: (x2) => {
-      state.date = Time(x2.readBigInt64BE(9));
-      state.lsn = x2.subarray(1, 9);
-    },
-    I: (x2) => {
-      let i = 1;
-      const relation = state[x2.readUInt32BE(i)];
-      const { row } = tuples(x2, relation.columns, i += 7, transform);
-      handle(row, {
-        command: "insert",
-        relation
-      });
-    },
-    D: (x2) => {
-      let i = 1;
-      const relation = state[x2.readUInt32BE(i)];
-      i += 4;
-      const key = x2[i] === 75;
-      handle(
-        key || x2[i] === 79 ? tuples(x2, relation.columns, i += 3, transform).row : null,
-        {
-          command: "delete",
-          relation,
-          key
-        }
-      );
-    },
-    U: (x2) => {
-      let i = 1;
-      const relation = state[x2.readUInt32BE(i)];
-      i += 4;
-      const key = x2[i] === 75;
-      const xs = key || x2[i] === 79 ? tuples(x2, relation.columns, i += 3, transform) : null;
-      xs && (i = xs.i);
-      const { row } = tuples(x2, relation.columns, i + 3, transform);
-      handle(row, {
-        command: "update",
-        relation,
-        key,
-        old: xs && xs.row
-      });
-    },
-    T: () => {
-    },
-    // Truncate,
-    C: () => {
-    }
-    // Commit
-  }).reduce(char, {})[x[0]](x);
-}
-function tuples(x, columns, xi, transform) {
-  let type, column, value;
-  const row = transform.raw ? new Array(columns.length) : {};
-  for (let i = 0; i < columns.length; i++) {
-    type = x[xi++];
-    column = columns[i];
-    value = type === 110 ? null : type === 117 ? void 0 : column.parser === void 0 ? x.toString("utf8", xi + 4, xi += 4 + x.readUInt32BE(xi)) : column.parser.array === true ? column.parser(x.toString("utf8", xi + 5, xi += 4 + x.readUInt32BE(xi))) : column.parser(x.toString("utf8", xi + 4, xi += 4 + x.readUInt32BE(xi)));
-    transform.raw ? row[i] = transform.raw === true ? value : transform.value.from ? transform.value.from(value, column) : value : row[column.name] = transform.value.from ? transform.value.from(value, column) : value;
-  }
-  return { i: xi, row: transform.row.from ? transform.row.from(row) : row };
-}
-function parseEvent(x) {
-  const xs = x.match(/^(\*|insert|update|delete)?:?([^.]+?\.?[^=]+)?=?(.+)?/i) || [];
-  if (!xs)
-    throw new Error("Malformed subscribe pattern: " + x);
-  const [, command, path, key] = xs;
-  return (command || "*") + (path ? ":" + (path.indexOf(".") === -1 ? "public." + path : path) : "") + (key ? "=" + key : "");
-}
-var noop2;
-var init_subscribe = __esm({
-  "node_modules/postgres/src/subscribe.js"() {
-    noop2 = () => {
-    };
-  }
-});
-function largeObject(sql, oid, mode = 131072 | 262144) {
-  return new Promise((resolve3, reject) => __async(null, null, function* () {
-    yield sql.begin((sql2) => __async(null, null, function* () {
-      let finish;
-      !oid && ([{ oid }] = yield sql2`select lo_creat(-1) as oid`);
-      const [{ fd }] = yield sql2`select lo_open(${oid}, ${mode}) as fd`;
-      const lo = {
-        writable,
-        readable,
-        close: () => sql2`select lo_close(${fd})`.then(finish),
-        tell: () => sql2`select lo_tell64(${fd})`,
-        read: (x) => sql2`select loread(${fd}, ${x}) as data`,
-        write: (x) => sql2`select lowrite(${fd}, ${x})`,
-        truncate: (x) => sql2`select lo_truncate64(${fd}, ${x})`,
-        seek: (x, whence = 0) => sql2`select lo_lseek64(${fd}, ${x}, ${whence})`,
-        size: () => sql2`
-          select
-            lo_lseek64(${fd}, location, 0) as position,
-            seek.size
-          from (
-            select
-              lo_lseek64($1, 0, 2) as size,
-              tell.location
-            from (select lo_tell64($1) as location) tell
-          ) seek
-        `
-      };
-      resolve3(lo);
-      return new Promise((r) => __async(null, null, function* () {
-        return finish = r;
-      }));
-      function readable() {
-        return __async(this, arguments, function* ({
-          highWaterMark = 2048 * 8,
-          start = 0,
-          end = Infinity
-        } = {}) {
-          let max = end - start;
-          start && (yield lo.seek(start));
-          return new Stream.Readable({
-            highWaterMark,
-            read(size2) {
-              return __async(this, null, function* () {
-                const l = size2 > max ? size2 - max : size2;
-                max -= size2;
-                const [{ data }] = yield lo.read(l);
-                this.push(data);
-                if (data.length < size2)
-                  this.push(null);
-              });
-            }
-          });
-        });
-      }
-      function writable() {
-        return __async(this, arguments, function* ({
-          highWaterMark = 2048 * 8,
-          start = 0
-        } = {}) {
-          start && (yield lo.seek(start));
-          return new Stream.Writable({
-            highWaterMark,
-            write(chunk, encoding, callback) {
-              lo.write(chunk).then(() => callback(), callback);
-            }
-          });
-        });
-      }
-    })).catch(reject);
-  }));
-}
-var init_large = __esm({
-  "node_modules/postgres/src/large.js"() {
-  }
-});
-
-// node_modules/postgres/src/index.js
-var src_exports = {};
-__export(src_exports, {
-  default: () => src_default
-});
-function Postgres(a, b2) {
-  const options = parseOptions(a, b2), subscribe = options.no_subscribe || Subscribe(Postgres, __spreadValues({}, options));
-  let ending = false;
-  const queries = queue_default(), connecting = queue_default(), reserved = queue_default(), closed = queue_default(), ended = queue_default(), open = queue_default(), busy = queue_default(), full = queue_default(), queues = { connecting, reserved, closed, ended, open, busy, full };
-  const connections = [...Array(options.max)].map(() => connection_default(options, queues, { onopen, onend, onclose }));
-  const sql = Sql(handler);
-  Object.assign(sql, {
-    get parameters() {
-      return options.parameters;
-    },
-    largeObject: largeObject.bind(null, sql),
-    subscribe,
-    CLOSE,
-    END: CLOSE,
-    PostgresError,
-    options,
-    reserve,
-    listen,
-    begin,
-    close,
-    end
-  });
-  return sql;
-  function Sql(handler2) {
-    handler2.debug = options.debug;
-    Object.entries(options.types).reduce((acc, [name, type]) => {
-      acc[name] = (x) => new Parameter(x, type.to);
-      return acc;
-    }, typed);
-    Object.assign(sql2, {
-      types: typed,
-      typed,
-      unsafe,
-      notify,
-      array,
-      json,
-      file
-    });
-    return sql2;
-    function typed(value, type) {
-      return new Parameter(value, type);
-    }
-    function sql2(strings, ...args) {
-      const query = strings && Array.isArray(strings.raw) ? new Query(strings, args, handler2, cancel) : typeof strings === "string" && !args.length ? new Identifier(options.transform.column.to ? options.transform.column.to(strings) : strings) : new Builder(strings, args);
-      return query;
-    }
-    function unsafe(string, args = [], options2 = {}) {
-      arguments.length === 2 && !Array.isArray(args) && (options2 = args, args = []);
-      const query = new Query([string], args, handler2, cancel, __spreadProps(__spreadValues({
-        prepare: false
-      }, options2), {
-        simple: "simple" in options2 ? options2.simple : args.length === 0
-      }));
-      return query;
-    }
-    function file(path, args = [], options2 = {}) {
-      arguments.length === 2 && !Array.isArray(args) && (options2 = args, args = []);
-      const query = new Query([], args, (query2) => {
-        fs.readFile(path, "utf8", (err, string) => {
-          if (err)
-            return query2.reject(err);
-          query2.strings = [string];
-          handler2(query2);
-        });
-      }, cancel, __spreadProps(__spreadValues({}, options2), {
-        simple: "simple" in options2 ? options2.simple : args.length === 0
-      }));
-      return query;
-    }
-  }
-  function listen(name, fn, onlisten) {
-    return __async(this, null, function* () {
-      const listener = { fn, onlisten };
-      const sql2 = listen.sql || (listen.sql = Postgres(__spreadProps(__spreadValues({}, options), {
-        max: 1,
-        idle_timeout: null,
-        max_lifetime: null,
-        fetch_types: false,
-        onclose() {
-          Object.entries(listen.channels).forEach(([name2, { listeners }]) => {
-            delete listen.channels[name2];
-            Promise.all(listeners.map((l) => listen(name2, l.fn, l.onlisten).catch(() => {
-            })));
-          });
-        },
-        onnotify(c, x) {
-          c in listen.channels && listen.channels[c].listeners.forEach((l) => l.fn(x));
-        }
-      })));
-      const channels = listen.channels || (listen.channels = {}), exists = name in channels;
-      if (exists) {
-        channels[name].listeners.push(listener);
-        const result2 = yield channels[name].result;
-        listener.onlisten && listener.onlisten();
-        return { state: result2.state, unlisten };
-      }
-      channels[name] = { result: sql2`listen ${sql2.unsafe('"' + name.replace(/"/g, '""') + '"')}`, listeners: [listener] };
-      const result = yield channels[name].result;
-      listener.onlisten && listener.onlisten();
-      return { state: result.state, unlisten };
-      function unlisten() {
-        return __async(this, null, function* () {
-          if (name in channels === false)
-            return;
-          channels[name].listeners = channels[name].listeners.filter((x) => x !== listener);
-          if (channels[name].listeners.length)
-            return;
-          delete channels[name];
-          return sql2`unlisten ${sql2.unsafe('"' + name.replace(/"/g, '""') + '"')}`;
-        });
-      }
-    });
-  }
-  function notify(channel, payload) {
-    return __async(this, null, function* () {
-      return yield sql`select pg_notify(${channel}, ${"" + payload})`;
-    });
-  }
-  function reserve() {
-    return __async(this, null, function* () {
-      const queue = queue_default();
-      const c = open.length ? open.shift() : yield new Promise((resolve3, reject) => {
-        const query = { reserve: resolve3, reject };
-        queries.push(query);
-        closed.length && connect(closed.shift(), query);
-      });
-      move(c, reserved);
-      c.reserved = () => queue.length ? c.execute(queue.shift()) : move(c, reserved);
-      c.reserved.release = true;
-      const sql2 = Sql(handler2);
-      sql2.release = () => {
-        c.reserved = null;
-        onopen(c);
-      };
-      return sql2;
-      function handler2(q) {
-        c.queue === full ? queue.push(q) : c.execute(q) || move(c, full);
-      }
-    });
-  }
-  function begin(options2, fn) {
-    return __async(this, null, function* () {
-      !fn && (fn = options2, options2 = "");
-      const queries2 = queue_default();
-      let savepoints = 0, connection2, prepare = null;
-      try {
-        yield sql.unsafe("begin " + options2.replace(/[^a-z ]/ig, ""), [], { onexecute }).execute();
-        return yield Promise.race([
-          scope(connection2, fn),
-          new Promise((_, reject) => connection2.onclose = reject)
-        ]);
-      } catch (error) {
-        throw error;
-      }
-      function scope(c, fn2, name) {
-        return __async(this, null, function* () {
-          const sql2 = Sql(handler2);
-          sql2.savepoint = savepoint;
-          sql2.prepare = (x) => prepare = x.replace(/[^a-z0-9$-_. ]/gi);
-          let uncaughtError, result;
-          name && (yield sql2`savepoint ${sql2(name)}`);
-          try {
-            result = yield new Promise((resolve3, reject) => {
-              const x = fn2(sql2);
-              Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve3, reject);
-            });
-            if (uncaughtError)
-              throw uncaughtError;
-          } catch (e) {
-            yield name ? sql2`rollback to ${sql2(name)}` : sql2`rollback`;
-            throw e instanceof PostgresError && e.code === "25P02" && uncaughtError || e;
-          }
-          if (!name) {
-            prepare ? yield sql2`prepare transaction '${sql2.unsafe(prepare)}'` : yield sql2`commit`;
-          }
-          return result;
-          function savepoint(name2, fn3) {
-            if (name2 && Array.isArray(name2.raw))
-              return savepoint((sql3) => sql3.apply(sql3, arguments));
-            arguments.length === 1 && (fn3 = name2, name2 = null);
-            return scope(c, fn3, "s" + savepoints++ + (name2 ? "_" + name2 : ""));
-          }
-          function handler2(q) {
-            q.catch((e) => uncaughtError || (uncaughtError = e));
-            c.queue === full ? queries2.push(q) : c.execute(q) || move(c, full);
-          }
-        });
-      }
-      function onexecute(c) {
-        connection2 = c;
-        move(c, reserved);
-        c.reserved = () => queries2.length ? c.execute(queries2.shift()) : move(c, reserved);
-      }
-    });
-  }
-  function move(c, queue) {
-    c.queue.remove(c);
-    queue.push(c);
-    c.queue = queue;
-    queue === open ? c.idleTimer.start() : c.idleTimer.cancel();
-    return c;
-  }
-  function json(x) {
-    return new Parameter(x, 3802);
-  }
-  function array(x, type) {
-    if (!Array.isArray(x))
-      return array(Array.from(arguments));
-    return new Parameter(x, type || (x.length ? inferType(x) || 25 : 0), options.shared.typeArrayMap);
-  }
-  function handler(query) {
-    if (ending)
-      return query.reject(Errors.connection("CONNECTION_ENDED", options, options));
-    if (open.length)
-      return go(open.shift(), query);
-    if (closed.length)
-      return connect(closed.shift(), query);
-    busy.length ? go(busy.shift(), query) : queries.push(query);
-  }
-  function go(c, query) {
-    return c.execute(query) ? move(c, busy) : move(c, full);
-  }
-  function cancel(query) {
-    return new Promise((resolve3, reject) => {
-      query.state ? query.active ? connection_default(options).cancel(query.state, resolve3, reject) : query.cancelled = { resolve: resolve3, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve3());
-    });
-  }
-  function end() {
-    return __async(this, arguments, function* ({ timeout = null } = {}) {
-      if (ending)
-        return ending;
-      yield 1;
-      let timer2;
-      return ending = Promise.race([
-        new Promise((r) => timeout !== null && (timer2 = setTimeout(destroy, timeout * 1e3, r))),
-        Promise.all(connections.map((c) => c.end()).concat(
-          listen.sql ? listen.sql.end({ timeout: 0 }) : [],
-          subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []
-        ))
-      ]).then(() => clearTimeout(timer2));
-    });
-  }
-  function close() {
-    return __async(this, null, function* () {
-      yield Promise.all(connections.map((c) => c.end()));
-    });
-  }
-  function destroy(resolve3) {
-    return __async(this, null, function* () {
-      yield Promise.all(connections.map((c) => c.terminate()));
-      while (queries.length)
-        queries.shift().reject(Errors.connection("CONNECTION_DESTROYED", options));
-      resolve3();
-    });
-  }
-  function connect(c, query) {
-    move(c, connecting);
-    c.connect(query);
-    return c;
-  }
-  function onend(c) {
-    move(c, ended);
-  }
-  function onopen(c) {
-    if (queries.length === 0)
-      return move(c, open);
-    let max = Math.ceil(queries.length / (connecting.length + 1)), ready = true;
-    while (ready && queries.length && max-- > 0) {
-      const query = queries.shift();
-      if (query.reserve)
-        return query.reserve(c);
-      ready = c.execute(query);
-    }
-    ready ? move(c, busy) : move(c, full);
-  }
-  function onclose(c, e) {
-    move(c, closed);
-    c.reserved = null;
-    c.onclose && (c.onclose(e), c.onclose = null);
-    options.onclose && options.onclose(c.id);
-    queries.length && connect(c, queries.shift());
-  }
-}
-function parseOptions(a, b2) {
-  if (a && a.shared)
-    return a;
-  const env = process.env, o = (!a || typeof a === "string" ? b2 : a) || {}, { url, multihost } = parseUrl(a), query = [...url.searchParams].reduce((a2, [b3, c]) => (a2[b3] = c, a2), {}), host = o.hostname || o.host || multihost || url.hostname || env.PGHOST || "localhost", port = o.port || url.port || env.PGPORT || 5432, user = o.user || o.username || url.username || env.PGUSERNAME || env.PGUSER || osUsername();
-  o.no_prepare && (o.prepare = false);
-  query.sslmode && (query.ssl = query.sslmode, delete query.sslmode);
-  "timeout" in o && (console.log("The timeout option is deprecated, use idle_timeout instead"), o.idle_timeout = o.timeout);
-  query.sslrootcert === "system" && (query.ssl = "verify-full");
-  const ints = ["idle_timeout", "connect_timeout", "max_lifetime", "max_pipeline", "backoff", "keep_alive"];
-  const defaults = {
-    max: globalThis.Cloudflare ? 3 : 10,
-    ssl: false,
-    sslnegotiation: null,
-    idle_timeout: null,
-    connect_timeout: 30,
-    max_lifetime,
-    max_pipeline: 100,
-    backoff,
-    keep_alive: 60,
-    prepare: true,
-    debug: false,
-    fetch_types: true,
-    publications: "alltables",
-    target_session_attrs: null
-  };
-  return __spreadValues(__spreadProps(__spreadValues({
-    host: Array.isArray(host) ? host : host.split(",").map((x) => x.split(":")[0]),
-    port: Array.isArray(port) ? port : host.split(",").map((x) => parseInt(x.split(":")[1] || port)),
-    path: o.path || host.indexOf("/") > -1 && host + "/.s.PGSQL." + port,
-    database: o.database || o.db || (url.pathname || "").slice(1) || env.PGDATABASE || user,
-    user,
-    pass: o.pass || o.password || url.password || env.PGPASSWORD || ""
-  }, Object.entries(defaults).reduce(
-    (acc, [k, d]) => {
-      const value = k in o ? o[k] : k in query ? query[k] === "disable" || query[k] === "false" ? false : query[k] : env["PG" + k.toUpperCase()] || d;
-      acc[k] = typeof value === "string" && ints.includes(k) ? +value : value;
-      return acc;
-    },
-    {}
-  )), {
-    connection: __spreadValues(__spreadValues({
-      application_name: env.PGAPPNAME || "postgres.js"
-    }, o.connection), Object.entries(query).reduce((acc, [k, v]) => (k in defaults || (acc[k] = v), acc), {})),
-    types: o.types || {},
-    target_session_attrs: tsa(o, url, env),
-    onnotice: o.onnotice,
-    onnotify: o.onnotify,
-    onclose: o.onclose,
-    onparameter: o.onparameter,
-    socket: o.socket,
-    transform: parseTransform(o.transform || { undefined: void 0 }),
-    parameters: {},
-    shared: { retries: 0, typeArrayMap: {} }
-  }), mergeUserTypes(o.types));
-}
-function tsa(o, url, env) {
-  const x = o.target_session_attrs || url.searchParams.get("target_session_attrs") || env.PGTARGETSESSIONATTRS;
-  if (!x || ["read-write", "read-only", "primary", "standby", "prefer-standby"].includes(x))
-    return x;
-  throw new Error("target_session_attrs " + x + " is not supported");
-}
-function backoff(retries) {
-  return (0.5 + Math.random() / 2) * Math.min(__pow(3, retries) / 100, 20);
-}
-function max_lifetime() {
-  return 60 * (30 + Math.random() * 30);
-}
-function parseTransform(x) {
-  return {
-    undefined: x.undefined,
-    column: {
-      from: typeof x.column === "function" ? x.column : x.column && x.column.from,
-      to: x.column && x.column.to
-    },
-    value: {
-      from: typeof x.value === "function" ? x.value : x.value && x.value.from,
-      to: x.value && x.value.to
-    },
-    row: {
-      from: typeof x.row === "function" ? x.row : x.row && x.row.from,
-      to: x.row && x.row.to
-    }
-  };
-}
-function parseUrl(url) {
-  if (!url || typeof url !== "string")
-    return { url: { searchParams: /* @__PURE__ */ new Map() } };
-  let host = url;
-  host = host.slice(host.indexOf("://") + 3).split(/[?/]/)[0];
-  host = decodeURIComponent(host.slice(host.indexOf("@") + 1));
-  const urlObj = new URL(url.replace(host, host.split(",")[0]));
-  return {
-    url: {
-      username: decodeURIComponent(urlObj.username),
-      password: decodeURIComponent(urlObj.password),
-      host: urlObj.host,
-      hostname: urlObj.hostname,
-      port: urlObj.port,
-      pathname: urlObj.pathname,
-      searchParams: urlObj.searchParams
-    },
-    multihost: host.indexOf(",") > -1 && host
-  };
-}
-function osUsername() {
-  try {
-    return os.userInfo().username;
-  } catch (_) {
-    return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
-  }
-}
-var src_default;
-var init_src = __esm({
-  "node_modules/postgres/src/index.js"() {
-    init_types();
-    init_connection();
-    init_query();
-    init_queue();
-    init_errors();
-    init_subscribe();
-    init_large();
-    Object.assign(Postgres, {
-      PostgresError,
-      toPascal,
-      pascal,
-      toCamel,
-      camel,
-      toKebab,
-      kebab,
-      fromPascal,
-      fromCamel,
-      fromKebab,
-      BigInt: {
-        to: 20,
-        from: [20],
-        parse: (x) => BigInt(x),
-        // eslint-disable-line
-        serialize: (x) => x.toString()
-      }
-    });
-    src_default = Postgres;
-  }
-});
-
 // package.json
 var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.75.5",
+      version: "1.75.7",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
       types: "dist/index.d.ts",
       bin: {
-        "prisma-sql-generator": "./dist/generator.cjs"
+        "prisma-sql-generator": "./dist/generator.cjs",
+        "prisma-sql-collect-stats": "./dist/collect-planner-stats.cjs"
       },
       exports: {
         ".": {
@@ -2379,7 +136,8 @@ var require_package = __commonJS({
       dependencies: {
         "@dee-wan/schema-parser": "1.4.0",
         "@prisma/generator-helper": "^7.4.0",
-        "@prisma/internals": "^7.4.0"
+        "@prisma/internals": "^7.4.0",
+        postgres: "^3.4.8"
       },
       devDependencies: {
         "@faker-js/faker": "^10.2.0",
@@ -2393,7 +151,6 @@ var require_package = __commonJS({
         "better-sqlite3": "^12.6.2",
         "drizzle-kit": "^0.31.8",
         "drizzle-orm": "^0.45.1",
-        postgres: "^3.4.8",
         tsup: "^8.5.1",
         tsx: "^4.21.0",
         typescript: "^5.9.3",
@@ -3679,9 +1436,9 @@ function findTiebreakerField(model) {
   if (scalarSet.has("id")) return "id";
   return null;
 }
-function hasTiebreaker(orderBy, parse2, field) {
+function hasTiebreaker(orderBy, parse, field) {
   if (!isNotNullish(orderBy)) return false;
-  const normalized = normalizeOrderByInput(orderBy, parse2);
+  const normalized = normalizeOrderByInput(orderBy, parse);
   return normalized.some(
     (obj) => Object.prototype.hasOwnProperty.call(obj, field)
   );
@@ -4989,7 +2746,7 @@ function extractReferencedParams(whereClause, specParams) {
     return { cleanWhere: whereClause, params: [] };
   }
   const allParams = Array.isArray(specParams) ? specParams : typeof specParams.snapshot === "function" ? specParams.snapshot().params : [];
-  const refs = Array.from(refSet).sort((a, b2) => a - b2);
+  const refs = Array.from(refSet).sort((a, b) => a - b);
   const params = [];
   const indexMap = /* @__PURE__ */ new Map();
   for (const oldIdx of refs) {
@@ -4997,7 +2754,7 @@ function extractReferencedParams(whereClause, specParams) {
     indexMap.set(oldIdx, params.length);
   }
   let cleanWhere = whereClause;
-  const sorted = Array.from(indexMap.entries()).sort((a, b2) => b2[0] - a[0]);
+  const sorted = Array.from(indexMap.entries()).sort((a, b) => b[0] - a[0]);
   for (const [oldIdx, newIdx] of sorted) {
     cleanWhere = cleanWhere.split(`$${oldIdx}`).join(`$${newIdx}`);
   }
@@ -5005,7 +2762,7 @@ function extractReferencedParams(whereClause, specParams) {
 }
 function buildFlatJoinSql(spec) {
   const {
-    select: select2,
+    select,
     from,
     whereClause,
     whereJoins,
@@ -5073,7 +2830,7 @@ function buildFlatJoinSql(spec) {
   if (built.joins.length === 0) {
     return emptyResult;
   }
-  const baseSelect = (select2 != null ? select2 : "").trim();
+  const baseSelect = (select != null ? select : "").trim();
   const allSelects = [baseSelect, ...built.selects].filter((s) => s && s.trim().length > 0).join(SQL_SEPARATORS.FIELD_LIST);
   if (!allSelects) {
     throw new Error("Flat-join SELECT requires at least one selected field");
@@ -6333,12 +4090,12 @@ function maybeReverseNegativeTake(takeVal, hasOrderBy, orderByInput) {
 
 // src/builder/select/lateral-join.ts
 function createParamCollector() {
-  const values2 = [];
+  const values = [];
   return {
-    values: values2,
+    values,
     add(value) {
-      values2.push(value);
-      return `$${values2.length}`;
+      values.push(value);
+      return `$${values.length}`;
     }
   };
 }
@@ -6365,14 +4122,14 @@ function reindexWhereParams(whereClause, specParams, collector) {
   }
   if (refSet.size === 0) return whereClause;
   const allParams = Array.isArray(specParams) ? specParams : typeof specParams.snapshot === "function" ? specParams.snapshot().params : [];
-  const refs = Array.from(refSet).sort((a, b2) => a - b2);
+  const refs = Array.from(refSet).sort((a, b) => a - b);
   const indexMap = /* @__PURE__ */ new Map();
   for (const oldIdx of refs) {
     collector.values.push(allParams[oldIdx - 1]);
     indexMap.set(oldIdx, collector.values.length);
   }
   let clean = whereClause;
-  const sorted = Array.from(indexMap.entries()).sort((a, b2) => b2[0] - a[0]);
+  const sorted = Array.from(indexMap.entries()).sort((a, b) => b[0] - a[0]);
   for (const [oldIdx, newIdx] of sorted) {
     clean = clean.split(`$${oldIdx}`).join(`$${newIdx}`);
   }
@@ -6703,8 +4460,8 @@ Hint: When using distinct with SQLite:
   }
   return unquoteIdent(column);
 }
-function parseSimpleScalarSelect(select2, fromAlias) {
-  const raw = select2.trim();
+function parseSimpleScalarSelect(select, fromAlias) {
+  const raw = select.trim();
   if (raw.length === 0) return [];
   const parts = raw.split(SQL_SEPARATORS.FIELD_LIST);
   const names = [];
@@ -6917,8 +4674,8 @@ function resolveCountSelect(countSelectRaw, model) {
 }
 function buildIncludeColumns(spec) {
   var _a3, _b, _c, _d, _e;
-  const { select: select2, includes, dialect, model, schemas, from, params } = spec;
-  const baseSelect = (select2 != null ? select2 : "").trim();
+  const { select, includes, dialect, model, schemas, from, params } = spec;
+  const baseSelect = (select != null ? select : "").trim();
   let countCols = "";
   let countJoins = [];
   const countSelectRaw = (_e = (_b = (_a3 = spec.args) == null ? void 0 : _a3.select) == null ? void 0 : _b[COUNT_SELECT_KEY]) != null ? _e : (_d = (_c = spec.args) == null ? void 0 : _c.include) == null ? void 0 : _d[COUNT_SELECT_KEY];
@@ -7078,7 +4835,7 @@ function hasNestedIncludes(includeSpec) {
 }
 function constructFinalSql(spec) {
   const {
-    select: select2,
+    select,
     from,
     whereClause,
     whereJoins,
@@ -7161,7 +4918,7 @@ function constructFinalSql(spec) {
   parts.push(SQL_TEMPLATES.SELECT);
   const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct, model) : null;
   if (distinctOn) parts.push(distinctOn);
-  const baseSelect = (select2 != null ? select2 : "").trim();
+  const baseSelect = (select != null ? select : "").trim();
   const fullSelectList = buildSelectList(baseSelect, includeCols);
   if (!isNonEmptyString(fullSelectList)) {
     throw new Error("SELECT requires at least one selected field or include");
@@ -7197,9 +4954,9 @@ function constructFinalSql(spec) {
 
 // src/builder/select/fields.ts
 var DEFAULT_SELECT_CACHE = /* @__PURE__ */ new WeakMap();
-function toSelectEntries(select2) {
+function toSelectEntries(select) {
   const out = [];
-  for (const [k, v] of Object.entries(select2)) {
+  for (const [k, v] of Object.entries(select)) {
     if (v !== false && v !== void 0) out.push([k, v]);
   }
   return out;
@@ -7922,7 +5679,7 @@ function resolveRelationOrderByChain(relationFieldName, value, currentModel, cur
       `Relation orderBy nesting too deep (max ${MAX_RELATION_ORDER_BY_DEPTH} levels)`
     );
   }
-  if ("_count" in value) {
+  if ("_count" in value && value._count !== void 0) {
     throw new Error(
       `Relation orderBy with _count on '${relationFieldName}' is not yet supported by prisma-sql`
     );
@@ -7951,7 +5708,7 @@ function resolveRelationOrderByChain(relationFieldName, value, currentModel, cur
   ctx.joins.push(`LEFT JOIN ${tableRef} ${joinAlias} ON ${cond}`);
   const relScalarSet = getScalarFieldSet(relatedModel);
   const relRelationSet = getRelationFieldSet(relatedModel);
-  const nestedEntries = Object.entries(value);
+  const nestedEntries = Object.entries(value).filter(([, v]) => v !== void 0);
   const orderFragments = [];
   for (const [nestedField, nestedValue] of nestedEntries) {
     if (relScalarSet.has(nestedField)) {
@@ -8810,11 +6567,11 @@ function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model
   if (selectFields.length === 0) {
     return buildSimpleCountSql(whereResult, tableName, alias, d);
   }
-  const select2 = {};
-  for (const f of selectFields) select2[f] = true;
+  const select = {};
+  for (const f of selectFields) select[f] = true;
   const subArgs = __spreadProps(__spreadValues({}, args), {
     include: void 0,
-    select: select2
+    select
   });
   const subSchemas = Array.isArray(schemas) && schemas.length > 0 ? schemas : [model];
   const sub = buildSelectSql({
@@ -9037,7 +6794,7 @@ function normalizeSqlAndMappingsForDialect(sql, paramMappings, dialect) {
   return { sql: normalizedSql, paramMappings: expandedMappings };
 }
 function buildParamsFromMappings(mappings) {
-  const sorted = [...mappings].sort((a, b2) => a.index - b2.index);
+  const sorted = [...mappings].sort((a, b) => a.index - b.index);
   const staticParams = [];
   const dynamicKeys = [];
   let paramOrder = "";
@@ -9579,9 +7336,9 @@ function createDatabaseExecutor(params) {
   return __async(this, null, function* () {
     const { databaseUrl, dialect } = params;
     if (dialect === "postgres") {
-      const postgres2 = yield Promise.resolve().then(() => (init_src(), src_exports));
+      const postgres = yield import('postgres');
       cleanDatabaseUrl(databaseUrl);
-      const sql = postgres2.default(databaseUrl, { max: 1 });
+      const sql = postgres.default(databaseUrl, { max: 1 });
       return {
         executor: {
           query: (sqlStr, params2) => __async(null, null, function* () {
@@ -9753,7 +7510,7 @@ function measureRoundtripCost(params) {
       yield executor.query("SELECT 1");
       roundtripTimes.push(performance.now() - start);
     }
-    roundtripTimes.sort((a, b2) => a - b2);
+    roundtripTimes.sort((a, b) => a - b);
     const medianRoundtrip = roundtripTimes[Math.floor(SAMPLES / 2)];
     console.log(
       `  [roundtrip] SELECT 1 times (ms): min=${roundtripTimes[0].toFixed(3)} median=${medianRoundtrip.toFixed(3)} max=${roundtripTimes[SAMPLES - 1].toFixed(3)}`
@@ -9791,7 +7548,7 @@ function estimateFromQueryPairRatio(params) {
       yield executor.query(`SELECT * FROM ${tableName} LIMIT ${smallLimit}`);
       smallTimes.push(performance.now() - start);
     }
-    smallTimes.sort((a, b2) => a - b2);
+    smallTimes.sort((a, b) => a - b);
     const medianSmall = smallTimes[Math.floor(SAMPLES / 2)];
     const largeTimes = [];
     let actualLargeRows = 0;
@@ -9803,7 +7560,7 @@ function estimateFromQueryPairRatio(params) {
       largeTimes.push(performance.now() - start);
       actualLargeRows = rows.length;
     }
-    largeTimes.sort((a, b2) => a - b2);
+    largeTimes.sort((a, b) => a - b);
     const medianLarge = largeTimes[Math.floor(SAMPLES / 2)];
     const rowDiff = actualLargeRows - smallLimit;
     const timeDiff = medianLarge - medianSmall;
@@ -9831,7 +7588,7 @@ function estimateFromQueryPairRatio(params) {
       yield executor.query(`SELECT * FROM ${tableName} LIMIT ${smallLimit}`);
       sequentialTimes.push(performance.now() - start);
     }
-    sequentialTimes.sort((a, b2) => a - b2);
+    sequentialTimes.sort((a, b) => a - b);
     const median3Sequential = sequentialTimes[Math.floor(SAMPLES / 2)];
     const marginalQueryCost = (median3Sequential - medianSmall) / 2;
     console.log(
@@ -9878,7 +7635,7 @@ function measureJsonOverhead(params) {
       yield executor.query(rawSql);
       rawTimes.push(performance.now() - start);
     }
-    rawTimes.sort((a, b2) => a - b2);
+    rawTimes.sort((a, b) => a - b);
     const medianRaw = rawTimes[Math.floor(SAMPLES / 2)];
     const aggTimes = [];
     for (let i = 0; i < SAMPLES; i++) {
@@ -9886,7 +7643,7 @@ function measureJsonOverhead(params) {
       yield executor.query(aggSql);
       aggTimes.push(performance.now() - start);
     }
-    aggTimes.sort((a, b2) => a - b2);
+    aggTimes.sort((a, b) => a - b);
     const medianAgg = aggTimes[Math.floor(SAMPLES / 2)];
     const factor = medianRaw > 0.01 ? medianAgg / medianRaw : 3;
     console.log(`  [json] Raw ${limit} rows: ${medianRaw.toFixed(3)}ms`);
@@ -10134,6 +7891,7 @@ function processAllModelDirectives(directiveResults, config) {
   }
   return { queries, skippedCount };
 }
+var DB_CONNECT_TIMEOUT_MS = 5e3;
 function generateClient(options) {
   return __async(this, null, function* () {
     var _a3;
@@ -10144,9 +7902,7 @@ function generateClient(options) {
     const directiveResults = processAllDirectives(
       datamodel.models,
       datamodel,
-      {
-        skipInvalid: config.skipInvalid
-      }
+      { skipInvalid: config.skipInvalid }
     );
     const { queries, skippedCount } = processAllModelDirectives(
       directiveResults,
@@ -10159,13 +7915,31 @@ function generateClient(options) {
       let executor = options.executor;
       let cleanup;
       if (!executor && datasourceUrl) {
+        let timedOut = false;
+        const timeoutHandle = new Promise((_, reject) => {
+          var _a4;
+          const id = setTimeout(() => {
+            timedOut = true;
+            reject(
+              new Error(
+                `DB connection timed out after ${DB_CONNECT_TIMEOUT_MS}ms`
+              )
+            );
+          }, DB_CONNECT_TIMEOUT_MS);
+          (_a4 = id.unref) == null ? void 0 : _a4.call(id);
+        });
         try {
-          const dbConn = yield createDatabaseExecutor({
-            databaseUrl: datasourceUrl,
-            dialect: config.dialect
-          });
-          executor = dbConn.executor;
-          cleanup = dbConn.cleanup;
+          const dbConn = yield Promise.race([
+            createDatabaseExecutor({
+              databaseUrl: datasourceUrl,
+              dialect: config.dialect
+            }),
+            timeoutHandle
+          ]);
+          if (!timedOut) {
+            executor = dbConn.executor;
+            cleanup = dbConn.cleanup;
+          }
         } catch (error) {
           console.warn(
             "\u26A0 Failed to connect:",