@netlify/plugin-nextjs 5.7.2 → 5.7.3

package/dist/run/handlers/tracing.js

@@ -39215,13 +39215,13 @@ var require_package2 = __commonJS({
   "node_modules/@grpc/grpc-js/package.json"(exports2, module2) {
     module2.exports = {
       name: "@grpc/grpc-js",
-      version: "1.10.1",
+      version: "1.11.3",
       description: "gRPC Library for Node - pure JS implementation",
       homepage: "https://grpc.io/",
       repository: "https://github.com/grpc/grpc-node/tree/master/packages/grpc-js",
       main: "build/src/index.js",
       engines: {
-        node: "^8.13.0 || >=10.10.0"
+        node: ">=12.10.0"
       },
       keywords: [],
       author: {
@@ -39230,17 +39230,19 @@ var require_package2 = __commonJS({
       types: "build/src/index.d.ts",
       license: "Apache-2.0",
       devDependencies: {
-        "@types/gulp": "^4.0.6",
-        "@types/gulp-mocha": "0.0.32",
-        "@types/lodash": "^4.14.186",
-        "@types/mocha": "^5.2.6",
-        "@types/ncp": "^2.0.1",
-        "@types/pify": "^3.0.2",
-        "@types/semver": "^7.3.9",
-        "@typescript-eslint/eslint-plugin": "^5.59.11",
-        "@typescript-eslint/parser": "^5.59.11",
-        "@typescript-eslint/typescript-estree": "^5.59.11",
-        "clang-format": "^1.0.55",
+        "@grpc/proto-loader": "file:../proto-loader",
+        "@types/gulp": "^4.0.17",
+        "@types/gulp-mocha": "0.0.37",
+        "@types/lodash": "^4.14.202",
+        "@types/mocha": "^10.0.6",
+        "@types/ncp": "^2.0.8",
+        "@types/node": ">=20.11.20",
+        "@types/pify": "^5.0.4",
+        "@types/semver": "^7.5.8",
+        "@typescript-eslint/eslint-plugin": "^7.1.0",
+        "@typescript-eslint/parser": "^7.1.0",
+        "@typescript-eslint/typescript-estree": "^7.1.0",
+        "clang-format": "^1.8.0",
         eslint: "^8.42.0",
         "eslint-config-prettier": "^8.8.0",
         "eslint-plugin-node": "^11.1.0",
@@ -39248,16 +39250,16 @@ var require_package2 = __commonJS({
         execa: "^2.0.3",
         gulp: "^4.0.2",
         "gulp-mocha": "^6.0.0",
-        lodash: "^4.17.4",
+        lodash: "^4.17.21",
         madge: "^5.0.1",
         "mocha-jenkins-reporter": "^0.4.1",
         ncp: "^2.0.0",
         pify: "^4.0.1",
         prettier: "^2.8.8",
         rimraf: "^3.0.2",
-        semver: "^7.3.5",
-        "ts-node": "^10.9.1",
-        typescript: "^5.1.3"
+        semver: "^7.6.0",
+        "ts-node": "^10.9.2",
+        typescript: "^5.3.3"
       },
       contributors: [
         {
@@ -39280,8 +39282,8 @@ var require_package2 = __commonJS({
         "generate-test-types": "proto-loader-gen-types --keepCase --longs String --enums String --defaults --oneofs --includeComments --include-dirs test/fixtures/ -O test/generated/ --grpcLib ../../src/index test_service.proto"
       },
       dependencies: {
-        "@grpc/proto-loader": "^0.7.8",
-        "@types/node": ">=12.12.47"
+        "@grpc/proto-loader": "^0.7.13",
+        "@js-sdsl/ordered-map": "^4.4.2"
       },
       files: [
         "src/**/*.ts",
@@ -40088,10 +40090,10 @@ var require_service_config = __commonJS({
         throw new Error("Invalid method config retry policy: maxAttempts must be an integer at least 2");
       }
       if (!("initialBackoff" in obj) || typeof obj.initialBackoff !== "string" || !DURATION_REGEX.test(obj.initialBackoff)) {
-        throw new Error("Invalid method config retry policy: initialBackoff must be a string consisting of a positive integer followed by s");
+        throw new Error("Invalid method config retry policy: initialBackoff must be a string consisting of a positive integer or decimal followed by s");
       }
       if (!("maxBackoff" in obj) || typeof obj.maxBackoff !== "string" || !DURATION_REGEX.test(obj.maxBackoff)) {
-        throw new Error("Invalid method config retry policy: maxBackoff must be a string consisting of a positive integer followed by s");
+        throw new Error("Invalid method config retry policy: maxBackoff must be a string consisting of a positive integer or decimal followed by s");
       }
       if (!("backoffMultiplier" in obj) || typeof obj.backoffMultiplier !== "number" || obj.backoffMultiplier <= 0) {
         throw new Error("Invalid method config retry policy: backoffMultiplier must be a number greater than 0");
@@ -40134,14 +40136,14 @@ var require_service_config = __commonJS({
         for (const value of obj.nonFatalStatusCodes) {
           if (typeof value === "number") {
             if (!Object.values(constants_1.Status).includes(value)) {
-              throw new Error("Invlid method config hedging policy: nonFatalStatusCodes value not in status code range");
+              throw new Error("Invalid method config hedging policy: nonFatalStatusCodes value not in status code range");
             }
           } else if (typeof value === "string") {
             if (!Object.values(constants_1.Status).includes(value.toUpperCase())) {
-              throw new Error("Invlid method config hedging policy: nonFatalStatusCodes value not a status code name");
+              throw new Error("Invalid method config hedging policy: nonFatalStatusCodes value not a status code name");
             }
           } else {
-            throw new Error("Invlid method config hedging policy: nonFatalStatusCodes value must be a string or number");
+            throw new Error("Invalid method config hedging policy: nonFatalStatusCodes value must be a string or number");
           }
         }
       }
@@ -41152,7 +41154,8 @@ var require_channel_options = __commonJS({
       "grpc.service_config_disable_resolution": true,
       "grpc.client_idle_timeout_ms": true,
       "grpc-node.tls_enable_trace": true,
-      "grpc.lb.ring_hash.ring_size_cap": true
+      "grpc.lb.ring_hash.ring_size_cap": true,
+      "grpc-node.retry_max_attempts_limit": true
     };
     function channelOptionsEqual(options1, options2) {
       const keys1 = Object.keys(options1).sort();
@@ -41201,7 +41204,11 @@ var require_subchannel_address = __commonJS({
     exports2.subchannelAddressEqual = subchannelAddressEqual;
     function subchannelAddressToString(address) {
       if (isTcpSubchannelAddress(address)) {
-        return address.host + ":" + address.port;
+        if ((0, net_1.isIPv6)(address.host)) {
+          return "[" + address.host + "]:" + address.port;
+        } else {
+          return address.host + ":" + address.port;
+        }
       } else {
         return address.path;
       }
@@ -41355,6 +41362,800 @@ var require_subchannel_address = __commonJS({
   }
 });
 
+// node_modules/@js-sdsl/ordered-map/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/@js-sdsl/ordered-map/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "t", {
+      value: true
+    });
+    var TreeNode = class {
+      constructor(t, e, s = 1) {
+        this.i = void 0;
+        this.h = void 0;
+        this.o = void 0;
+        this.u = t;
+        this.l = e;
+        this.p = s;
+      }
+      I() {
+        let t = this;
+        const e = t.o.o === t;
+        if (e && t.p === 1) {
+          t = t.h;
+        } else if (t.i) {
+          t = t.i;
+          while (t.h) {
+            t = t.h;
+          }
+        } else {
+          if (e) {
+            return t.o;
+          }
+          let s = t.o;
+          while (s.i === t) {
+            t = s;
+            s = t.o;
+          }
+          t = s;
+        }
+        return t;
+      }
+      B() {
+        let t = this;
+        if (t.h) {
+          t = t.h;
+          while (t.i) {
+            t = t.i;
+          }
+          return t;
+        } else {
+          let e = t.o;
+          while (e.h === t) {
+            t = e;
+            e = t.o;
+          }
+          if (t.h !== e) {
+            return e;
+          } else return t;
+        }
+      }
+      _() {
+        const t = this.o;
+        const e = this.h;
+        const s = e.i;
+        if (t.o === this) t.o = e;
+        else if (t.i === this) t.i = e;
+        else t.h = e;
+        e.o = t;
+        e.i = this;
+        this.o = e;
+        this.h = s;
+        if (s) s.o = this;
+        return e;
+      }
+      g() {
+        const t = this.o;
+        const e = this.i;
+        const s = e.h;
+        if (t.o === this) t.o = e;
+        else if (t.i === this) t.i = e;
+        else t.h = e;
+        e.o = t;
+        e.h = this;
+        this.o = e;
+        this.i = s;
+        if (s) s.o = this;
+        return e;
+      }
+    };
+    var TreeNodeEnableIndex = class extends TreeNode {
+      constructor() {
+        super(...arguments);
+        this.M = 1;
+      }
+      _() {
+        const t = super._();
+        this.O();
+        t.O();
+        return t;
+      }
+      g() {
+        const t = super.g();
+        this.O();
+        t.O();
+        return t;
+      }
+      O() {
+        this.M = 1;
+        if (this.i) {
+          this.M += this.i.M;
+        }
+        if (this.h) {
+          this.M += this.h.M;
+        }
+      }
+    };
+    var ContainerIterator = class {
+      constructor(t = 0) {
+        this.iteratorType = t;
+      }
+      equals(t) {
+        return this.T === t.T;
+      }
+    };
+    var Base = class {
+      constructor() {
+        this.m = 0;
+      }
+      get length() {
+        return this.m;
+      }
+      size() {
+        return this.m;
+      }
+      empty() {
+        return this.m === 0;
+      }
+    };
+    var Container = class extends Base {
+    };
+    function throwIteratorAccessError() {
+      throw new RangeError("Iterator access denied!");
+    }
+    var TreeContainer = class extends Container {
+      constructor(t = function(t2, e2) {
+        if (t2 < e2) return -1;
+        if (t2 > e2) return 1;
+        return 0;
+      }, e = false) {
+        super();
+        this.v = void 0;
+        this.A = t;
+        this.enableIndex = e;
+        this.N = e ? TreeNodeEnableIndex : TreeNode;
+        this.C = new this.N();
+      }
+      R(t, e) {
+        let s = this.C;
+        while (t) {
+          const i = this.A(t.u, e);
+          if (i < 0) {
+            t = t.h;
+          } else if (i > 0) {
+            s = t;
+            t = t.i;
+          } else return t;
+        }
+        return s;
+      }
+      K(t, e) {
+        let s = this.C;
+        while (t) {
+          const i = this.A(t.u, e);
+          if (i <= 0) {
+            t = t.h;
+          } else {
+            s = t;
+            t = t.i;
+          }
+        }
+        return s;
+      }
+      L(t, e) {
+        let s = this.C;
+        while (t) {
+          const i = this.A(t.u, e);
+          if (i < 0) {
+            s = t;
+            t = t.h;
+          } else if (i > 0) {
+            t = t.i;
+          } else return t;
+        }
+        return s;
+      }
+      k(t, e) {
+        let s = this.C;
+        while (t) {
+          const i = this.A(t.u, e);
+          if (i < 0) {
+            s = t;
+            t = t.h;
+          } else {
+            t = t.i;
+          }
+        }
+        return s;
+      }
+      P(t) {
+        while (true) {
+          const e = t.o;
+          if (e === this.C) return;
+          if (t.p === 1) {
+            t.p = 0;
+            return;
+          }
+          if (t === e.i) {
+            const s = e.h;
+            if (s.p === 1) {
+              s.p = 0;
+              e.p = 1;
+              if (e === this.v) {
+                this.v = e._();
+              } else e._();
+            } else {
+              if (s.h && s.h.p === 1) {
+                s.p = e.p;
+                e.p = 0;
+                s.h.p = 0;
+                if (e === this.v) {
+                  this.v = e._();
+                } else e._();
+                return;
+              } else if (s.i && s.i.p === 1) {
+                s.p = 1;
+                s.i.p = 0;
+                s.g();
+              } else {
+                s.p = 1;
+                t = e;
+              }
+            }
+          } else {
+            const s = e.i;
+            if (s.p === 1) {
+              s.p = 0;
+              e.p = 1;
+              if (e === this.v) {
+                this.v = e.g();
+              } else e.g();
+            } else {
+              if (s.i && s.i.p === 1) {
+                s.p = e.p;
+                e.p = 0;
+                s.i.p = 0;
+                if (e === this.v) {
+                  this.v = e.g();
+                } else e.g();
+                return;
+              } else if (s.h && s.h.p === 1) {
+                s.p = 1;
+                s.h.p = 0;
+                s._();
+              } else {
+                s.p = 1;
+                t = e;
+              }
+            }
+          }
+        }
+      }
+      S(t) {
+        if (this.m === 1) {
+          this.clear();
+          return;
+        }
+        let e = t;
+        while (e.i || e.h) {
+          if (e.h) {
+            e = e.h;
+            while (e.i) e = e.i;
+          } else {
+            e = e.i;
+          }
+          const s2 = t.u;
+          t.u = e.u;
+          e.u = s2;
+          const i = t.l;
+          t.l = e.l;
+          e.l = i;
+          t = e;
+        }
+        if (this.C.i === e) {
+          this.C.i = e.o;
+        } else if (this.C.h === e) {
+          this.C.h = e.o;
+        }
+        this.P(e);
+        let s = e.o;
+        if (e === s.i) {
+          s.i = void 0;
+        } else s.h = void 0;
+        this.m -= 1;
+        this.v.p = 0;
+        if (this.enableIndex) {
+          while (s !== this.C) {
+            s.M -= 1;
+            s = s.o;
+          }
+        }
+      }
+      U(t) {
+        const e = typeof t === "number" ? t : void 0;
+        const s = typeof t === "function" ? t : void 0;
+        const i = typeof t === "undefined" ? [] : void 0;
+        let r = 0;
+        let n = this.v;
+        const h = [];
+        while (h.length || n) {
+          if (n) {
+            h.push(n);
+            n = n.i;
+          } else {
+            n = h.pop();
+            if (r === e) return n;
+            i && i.push(n);
+            s && s(n, r, this);
+            r += 1;
+            n = n.h;
+          }
+        }
+        return i;
+      }
+      j(t) {
+        while (true) {
+          const e = t.o;
+          if (e.p === 0) return;
+          const s = e.o;
+          if (e === s.i) {
+            const i = s.h;
+            if (i && i.p === 1) {
+              i.p = e.p = 0;
+              if (s === this.v) return;
+              s.p = 1;
+              t = s;
+              continue;
+            } else if (t === e.h) {
+              t.p = 0;
+              if (t.i) {
+                t.i.o = e;
+              }
+              if (t.h) {
+                t.h.o = s;
+              }
+              e.h = t.i;
+              s.i = t.h;
+              t.i = e;
+              t.h = s;
+              if (s === this.v) {
+                this.v = t;
+                this.C.o = t;
+              } else {
+                const e2 = s.o;
+                if (e2.i === s) {
+                  e2.i = t;
+                } else e2.h = t;
+              }
+              t.o = s.o;
+              e.o = t;
+              s.o = t;
+              s.p = 1;
+            } else {
+              e.p = 0;
+              if (s === this.v) {
+                this.v = s.g();
+              } else s.g();
+              s.p = 1;
+              return;
+            }
+          } else {
+            const i = s.i;
+            if (i && i.p === 1) {
+              i.p = e.p = 0;
+              if (s === this.v) return;
+              s.p = 1;
+              t = s;
+              continue;
+            } else if (t === e.i) {
+              t.p = 0;
+              if (t.i) {
+                t.i.o = s;
+              }
+              if (t.h) {
+                t.h.o = e;
+              }
+              s.h = t.i;
+              e.i = t.h;
+              t.i = s;
+              t.h = e;
+              if (s === this.v) {
+                this.v = t;
+                this.C.o = t;
+              } else {
+                const e2 = s.o;
+                if (e2.i === s) {
+                  e2.i = t;
+                } else e2.h = t;
+              }
+              t.o = s.o;
+              e.o = t;
+              s.o = t;
+              s.p = 1;
+            } else {
+              e.p = 0;
+              if (s === this.v) {
+                this.v = s._();
+              } else s._();
+              s.p = 1;
+              return;
+            }
+          }
+          if (this.enableIndex) {
+            e.O();
+            s.O();
+            t.O();
+          }
+          return;
+        }
+      }
+      q(t, e, s) {
+        if (this.v === void 0) {
+          this.m += 1;
+          this.v = new this.N(t, e, 0);
+          this.v.o = this.C;
+          this.C.o = this.C.i = this.C.h = this.v;
+          return this.m;
+        }
+        let i;
+        const r = this.C.i;
+        const n = this.A(r.u, t);
+        if (n === 0) {
+          r.l = e;
+          return this.m;
+        } else if (n > 0) {
+          r.i = new this.N(t, e);
+          r.i.o = r;
+          i = r.i;
+          this.C.i = i;
+        } else {
+          const r2 = this.C.h;
+          const n2 = this.A(r2.u, t);
+          if (n2 === 0) {
+            r2.l = e;
+            return this.m;
+          } else if (n2 < 0) {
+            r2.h = new this.N(t, e);
+            r2.h.o = r2;
+            i = r2.h;
+            this.C.h = i;
+          } else {
+            if (s !== void 0) {
+              const r3 = s.T;
+              if (r3 !== this.C) {
+                const s2 = this.A(r3.u, t);
+                if (s2 === 0) {
+                  r3.l = e;
+                  return this.m;
+                } else if (s2 > 0) {
+                  const s3 = r3.I();
+                  const n3 = this.A(s3.u, t);
+                  if (n3 === 0) {
+                    s3.l = e;
+                    return this.m;
+                  } else if (n3 < 0) {
+                    i = new this.N(t, e);
+                    if (s3.h === void 0) {
+                      s3.h = i;
+                      i.o = s3;
+                    } else {
+                      r3.i = i;
+                      i.o = r3;
+                    }
+                  }
+                }
+              }
+            }
+            if (i === void 0) {
+              i = this.v;
+              while (true) {
+                const s2 = this.A(i.u, t);
+                if (s2 > 0) {
+                  if (i.i === void 0) {
+                    i.i = new this.N(t, e);
+                    i.i.o = i;
+                    i = i.i;
+                    break;
+                  }
+                  i = i.i;
+                } else if (s2 < 0) {
+                  if (i.h === void 0) {
+                    i.h = new this.N(t, e);
+                    i.h.o = i;
+                    i = i.h;
+                    break;
+                  }
+                  i = i.h;
+                } else {
+                  i.l = e;
+                  return this.m;
+                }
+              }
+            }
+          }
+        }
+        if (this.enableIndex) {
+          let t2 = i.o;
+          while (t2 !== this.C) {
+            t2.M += 1;
+            t2 = t2.o;
+          }
+        }
+        this.j(i);
+        this.m += 1;
+        return this.m;
+      }
+      H(t, e) {
+        while (t) {
+          const s = this.A(t.u, e);
+          if (s < 0) {
+            t = t.h;
+          } else if (s > 0) {
+            t = t.i;
+          } else return t;
+        }
+        return t || this.C;
+      }
+      clear() {
+        this.m = 0;
+        this.v = void 0;
+        this.C.o = void 0;
+        this.C.i = this.C.h = void 0;
+      }
+      updateKeyByIterator(t, e) {
+        const s = t.T;
+        if (s === this.C) {
+          throwIteratorAccessError();
+        }
+        if (this.m === 1) {
+          s.u = e;
+          return true;
+        }
+        const i = s.B().u;
+        if (s === this.C.i) {
+          if (this.A(i, e) > 0) {
+            s.u = e;
+            return true;
+          }
+          return false;
+        }
+        const r = s.I().u;
+        if (s === this.C.h) {
+          if (this.A(r, e) < 0) {
+            s.u = e;
+            return true;
+          }
+          return false;
+        }
+        if (this.A(r, e) >= 0 || this.A(i, e) <= 0) return false;
+        s.u = e;
+        return true;
+      }
+      eraseElementByPos(t) {
+        if (t < 0 || t > this.m - 1) {
+          throw new RangeError();
+        }
+        const e = this.U(t);
+        this.S(e);
+        return this.m;
+      }
+      eraseElementByKey(t) {
+        if (this.m === 0) return false;
+        const e = this.H(this.v, t);
+        if (e === this.C) return false;
+        this.S(e);
+        return true;
+      }
+      eraseElementByIterator(t) {
+        const e = t.T;
+        if (e === this.C) {
+          throwIteratorAccessError();
+        }
+        const s = e.h === void 0;
+        const i = t.iteratorType === 0;
+        if (i) {
+          if (s) t.next();
+        } else {
+          if (!s || e.i === void 0) t.next();
+        }
+        this.S(e);
+        return t;
+      }
+      getHeight() {
+        if (this.m === 0) return 0;
+        function traversal(t) {
+          if (!t) return 0;
+          return Math.max(traversal(t.i), traversal(t.h)) + 1;
+        }
+        return traversal(this.v);
+      }
+    };
+    var TreeIterator = class extends ContainerIterator {
+      constructor(t, e, s) {
+        super(s);
+        this.T = t;
+        this.C = e;
+        if (this.iteratorType === 0) {
+          this.pre = function() {
+            if (this.T === this.C.i) {
+              throwIteratorAccessError();
+            }
+            this.T = this.T.I();
+            return this;
+          };
+          this.next = function() {
+            if (this.T === this.C) {
+              throwIteratorAccessError();
+            }
+            this.T = this.T.B();
+            return this;
+          };
+        } else {
+          this.pre = function() {
+            if (this.T === this.C.h) {
+              throwIteratorAccessError();
+            }
+            this.T = this.T.B();
+            return this;
+          };
+          this.next = function() {
+            if (this.T === this.C) {
+              throwIteratorAccessError();
+            }
+            this.T = this.T.I();
+            return this;
+          };
+        }
+      }
+      get index() {
+        let t = this.T;
+        const e = this.C.o;
+        if (t === this.C) {
+          if (e) {
+            return e.M - 1;
+          }
+          return 0;
+        }
+        let s = 0;
+        if (t.i) {
+          s += t.i.M;
+        }
+        while (t !== e) {
+          const e2 = t.o;
+          if (t === e2.h) {
+            s += 1;
+            if (e2.i) {
+              s += e2.i.M;
+            }
+          }
+          t = e2;
+        }
+        return s;
+      }
+      isAccessible() {
+        return this.T !== this.C;
+      }
+    };
+    var OrderedMapIterator = class _OrderedMapIterator extends TreeIterator {
+      constructor(t, e, s, i) {
+        super(t, e, i);
+        this.container = s;
+      }
+      get pointer() {
+        if (this.T === this.C) {
+          throwIteratorAccessError();
+        }
+        const t = this;
+        return new Proxy([], {
+          get(e, s) {
+            if (s === "0") return t.T.u;
+            else if (s === "1") return t.T.l;
+            e[0] = t.T.u;
+            e[1] = t.T.l;
+            return e[s];
+          },
+          set(e, s, i) {
+            if (s !== "1") {
+              throw new TypeError("prop must be 1");
+            }
+            t.T.l = i;
+            return true;
+          }
+        });
+      }
+      copy() {
+        return new _OrderedMapIterator(this.T, this.C, this.container, this.iteratorType);
+      }
+    };
+    var OrderedMap = class extends TreeContainer {
+      constructor(t = [], e, s) {
+        super(e, s);
+        const i = this;
+        t.forEach(function(t2) {
+          i.setElement(t2[0], t2[1]);
+        });
+      }
+      begin() {
+        return new OrderedMapIterator(this.C.i || this.C, this.C, this);
+      }
+      end() {
+        return new OrderedMapIterator(this.C, this.C, this);
+      }
+      rBegin() {
+        return new OrderedMapIterator(this.C.h || this.C, this.C, this, 1);
+      }
+      rEnd() {
+        return new OrderedMapIterator(this.C, this.C, this, 1);
+      }
+      front() {
+        if (this.m === 0) return;
+        const t = this.C.i;
+        return [t.u, t.l];
+      }
+      back() {
+        if (this.m === 0) return;
+        const t = this.C.h;
+        return [t.u, t.l];
+      }
+      lowerBound(t) {
+        const e = this.R(this.v, t);
+        return new OrderedMapIterator(e, this.C, this);
+      }
+      upperBound(t) {
+        const e = this.K(this.v, t);
+        return new OrderedMapIterator(e, this.C, this);
+      }
+      reverseLowerBound(t) {
+        const e = this.L(this.v, t);
+        return new OrderedMapIterator(e, this.C, this);
+      }
+      reverseUpperBound(t) {
+        const e = this.k(this.v, t);
+        return new OrderedMapIterator(e, this.C, this);
+      }
+      forEach(t) {
+        this.U(function(e, s, i) {
+          t([e.u, e.l], s, i);
+        });
+      }
+      setElement(t, e, s) {
+        return this.q(t, e, s);
+      }
+      getElementByPos(t) {
+        if (t < 0 || t > this.m - 1) {
+          throw new RangeError();
+        }
+        const e = this.U(t);
+        return [e.u, e.l];
+      }
+      find(t) {
+        const e = this.H(this.v, t);
+        return new OrderedMapIterator(e, this.C, this);
+      }
+      getElementByKey(t) {
+        const e = this.H(this.v, t);
+        return e.l;
+      }
+      union(t) {
+        const e = this;
+        t.forEach(function(t2) {
+          e.setElement(t2[0], t2[1]);
+        });
+        return this.m;
+      }
+      *[Symbol.iterator]() {
+        const t = this.m;
+        const e = this.U();
+        for (let s = 0; s < t; ++s) {
+          const t2 = e[s];
+          yield [t2.u, t2.l];
+        }
+      }
+    };
+    exports2.OrderedMap = OrderedMap;
+  }
+});
+
 // node_modules/@grpc/grpc-js/build/src/admin.js
 var require_admin = __commonJS({
   "node_modules/@grpc/grpc-js/build/src/admin.js"(exports2) {
@@ -41931,7 +42732,8 @@ var require_client = __commonJS({
       return typeof arg === "function";
     }
     function getErrorStackString(error) {
-      return error.stack.split("\n").slice(1).join("\n");
+      var _a;
+      return ((_a = error.stack) === null || _a === void 0 ? void 0 : _a.split("\n").slice(1).join("\n")) || "no stack trace available";
     }
     var Client = class {
       constructor(address, credentials, options = {}) {
@@ -42044,7 +42846,7 @@ var require_client = __commonJS({
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           onReceiveMessage(message) {
             if (responseMessage !== null) {
-              call.cancelWithStatus(constants_1.Status.INTERNAL, "Too many responses received");
+              call.cancelWithStatus(constants_1.Status.UNIMPLEMENTED, "Too many responses received");
             }
             responseMessage = message;
           },
@@ -42057,7 +42859,7 @@ var require_client = __commonJS({
               if (responseMessage === null) {
                 const callerStack = getErrorStackString(callerStackError);
                 callProperties.callback((0, call_1.callErrorFromStatus)({
-                  code: constants_1.Status.INTERNAL,
+                  code: constants_1.Status.UNIMPLEMENTED,
                   details: "No message received",
                   metadata: status.metadata
                 }, callerStack));
@@ -42116,9 +42918,10 @@ var require_client = __commonJS({
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           onReceiveMessage(message) {
             if (responseMessage !== null) {
-              call.cancelWithStatus(constants_1.Status.INTERNAL, "Too many responses received");
+              call.cancelWithStatus(constants_1.Status.UNIMPLEMENTED, "Too many responses received");
             }
             responseMessage = message;
+            call.startRead();
           },
           onReceiveStatus(status) {
             if (receivedStatus) {
@@ -42129,7 +42932,7 @@ var require_client = __commonJS({
               if (responseMessage === null) {
                 const callerStack = getErrorStackString(callerStackError);
                 callProperties.callback((0, call_1.callErrorFromStatus)({
-                  code: constants_1.Status.INTERNAL,
+                  code: constants_1.Status.UNIMPLEMENTED,
                   details: "No message received",
                   metadata: status.metadata
                 }, callerStack));
@@ -48664,7 +49467,7 @@ var require_src30 = __commonJS({
   "node_modules/@grpc/proto-loader/build/src/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.loadFileDescriptorSetFromObject = exports2.loadFileDescriptorSetFromBuffer = exports2.fromJSON = exports2.loadSync = exports2.load = exports2.isAnyExtension = exports2.Long = void 0;
+    exports2.loadFileDescriptorSetFromObject = exports2.loadFileDescriptorSetFromBuffer = exports2.fromJSON = exports2.loadSync = exports2.load = exports2.IdempotencyLevel = exports2.isAnyExtension = exports2.Long = void 0;
     var camelCase = require_lodash();
     var Protobuf = require_protobufjs();
     var descriptor = require_descriptor2();
@@ -48675,6 +49478,12 @@ var require_src30 = __commonJS({
       return "@type" in obj && typeof obj["@type"] === "string";
     }
     exports2.isAnyExtension = isAnyExtension;
+    var IdempotencyLevel;
+    (function(IdempotencyLevel2) {
+      IdempotencyLevel2["IDEMPOTENCY_UNKNOWN"] = "IDEMPOTENCY_UNKNOWN";
+      IdempotencyLevel2["NO_SIDE_EFFECTS"] = "NO_SIDE_EFFECTS";
+      IdempotencyLevel2["IDEMPOTENT"] = "IDEMPOTENT";
+    })(IdempotencyLevel = exports2.IdempotencyLevel || (exports2.IdempotencyLevel = {}));
     var descriptorOptions = {
       longs: String,
       enums: String,
@@ -48723,6 +49532,24 @@ var require_src30 = __commonJS({
         return cls.encode(message).finish();
       };
     }
+    function mapMethodOptions(options) {
+      return (options || []).reduce((obj, item) => {
+        for (const [key, value] of Object.entries(item)) {
+          switch (key) {
+            case "uninterpreted_option":
+              obj.uninterpreted_option.push(item.uninterpreted_option);
+              break;
+            default:
+              obj[key] = value;
+          }
+        }
+        return obj;
+      }, {
+        deprecated: false,
+        idempotency_level: IdempotencyLevel.IDEMPOTENCY_UNKNOWN,
+        uninterpreted_option: []
+      });
+    }
     function createMethodDefinition(method, serviceName, options, fileDescriptors) {
       const requestType = method.resolvedRequestType;
       const responseType = method.resolvedResponseType;
@@ -48737,7 +49564,8 @@ var require_src30 = __commonJS({
         // TODO(murgatroid99): Find a better way to handle this
         originalName: camelCase(method.name),
         requestType: createMessageDefinition(requestType, fileDescriptors),
-        responseType: createMessageDefinition(responseType, fileDescriptors)
+        responseType: createMessageDefinition(responseType, fileDescriptors),
+        options: mapMethodOptions(method.parsedOptions)
       };
     }
     function createServiceDefinition(service, name2, options, fileDescriptors) {
@@ -48827,8 +49655,9 @@ var require_channelz = __commonJS({
   "node_modules/@grpc/grpc-js/build/src/channelz.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.setup = exports2.getChannelzServiceDefinition = exports2.getChannelzHandlers = exports2.unregisterChannelzRef = exports2.registerChannelzSocket = exports2.registerChannelzServer = exports2.registerChannelzSubchannel = exports2.registerChannelzChannel = exports2.ChannelzCallTracker = exports2.ChannelzChildrenTracker = exports2.ChannelzTrace = void 0;
+    exports2.setup = exports2.getChannelzServiceDefinition = exports2.getChannelzHandlers = exports2.unregisterChannelzRef = exports2.registerChannelzSocket = exports2.registerChannelzServer = exports2.registerChannelzSubchannel = exports2.registerChannelzChannel = exports2.ChannelzCallTrackerStub = exports2.ChannelzCallTracker = exports2.ChannelzChildrenTrackerStub = exports2.ChannelzChildrenTracker = exports2.ChannelzTrace = exports2.ChannelzTraceStub = void 0;
     var net_1 = __require("net");
+    var ordered_map_1 = require_cjs();
     var connectivity_state_1 = require_connectivity_state();
     var constants_1 = require_constants8();
     var subchannel_address_1 = require_subchannel_address();
@@ -48858,6 +49687,24 @@ var require_channelz = __commonJS({
       };
     }
     var TARGET_RETAINED_TRACES = 32;
+    var DEFAULT_MAX_RESULTS = 100;
+    var ChannelzTraceStub = class {
+      constructor() {
+        this.events = [];
+        this.creationTimestamp = /* @__PURE__ */ new Date();
+        this.eventsLogged = 0;
+      }
+      addTrace() {
+      }
+      getTraceMessage() {
+        return {
+          creation_timestamp: dateToProtoTimestamp(this.creationTimestamp),
+          num_events_logged: this.eventsLogged,
+          events: []
+        };
+      }
+    };
+    exports2.ChannelzTraceStub = ChannelzTraceStub;
     var ChannelzTrace = class {
       constructor() {
         this.events = [];
@@ -48897,99 +49744,62 @@ var require_channelz = __commonJS({
     exports2.ChannelzTrace = ChannelzTrace;
     var ChannelzChildrenTracker = class {
       constructor() {
-        this.channelChildren = /* @__PURE__ */ new Map();
-        this.subchannelChildren = /* @__PURE__ */ new Map();
-        this.socketChildren = /* @__PURE__ */ new Map();
+        this.channelChildren = new ordered_map_1.OrderedMap();
+        this.subchannelChildren = new ordered_map_1.OrderedMap();
+        this.socketChildren = new ordered_map_1.OrderedMap();
+        this.trackerMap = {
+          [
+            "channel"
+            /* EntityTypes.channel */
+          ]: this.channelChildren,
+          [
+            "subchannel"
+            /* EntityTypes.subchannel */
+          ]: this.subchannelChildren,
+          [
+            "socket"
+            /* EntityTypes.socket */
+          ]: this.socketChildren
+        };
       }
       refChild(child) {
-        var _a, _b, _c;
-        switch (child.kind) {
-          case "channel": {
-            const trackedChild = (_a = this.channelChildren.get(child.id)) !== null && _a !== void 0 ? _a : {
-              ref: child,
-              count: 0
-            };
-            trackedChild.count += 1;
-            this.channelChildren.set(child.id, trackedChild);
-            break;
-          }
-          case "subchannel": {
-            const trackedChild = (_b = this.subchannelChildren.get(child.id)) !== null && _b !== void 0 ? _b : {
-              ref: child,
-              count: 0
-            };
-            trackedChild.count += 1;
-            this.subchannelChildren.set(child.id, trackedChild);
-            break;
-          }
-          case "socket": {
-            const trackedChild = (_c = this.socketChildren.get(child.id)) !== null && _c !== void 0 ? _c : {
-              ref: child,
-              count: 0
-            };
-            trackedChild.count += 1;
-            this.socketChildren.set(child.id, trackedChild);
-            break;
-          }
+        const tracker = this.trackerMap[child.kind];
+        const trackedChild = tracker.find(child.id);
+        if (trackedChild.equals(tracker.end())) {
+          tracker.setElement(child.id, {
+            ref: child,
+            count: 1
+          }, trackedChild);
+        } else {
+          trackedChild.pointer[1].count += 1;
         }
       }
       unrefChild(child) {
-        switch (child.kind) {
-          case "channel": {
-            const trackedChild = this.channelChildren.get(child.id);
-            if (trackedChild !== void 0) {
-              trackedChild.count -= 1;
-              if (trackedChild.count === 0) {
-                this.channelChildren.delete(child.id);
-              } else {
-                this.channelChildren.set(child.id, trackedChild);
-              }
-            }
-            break;
-          }
-          case "subchannel": {
-            const trackedChild = this.subchannelChildren.get(child.id);
-            if (trackedChild !== void 0) {
-              trackedChild.count -= 1;
-              if (trackedChild.count === 0) {
-                this.subchannelChildren.delete(child.id);
-              } else {
-                this.subchannelChildren.set(child.id, trackedChild);
-              }
-            }
-            break;
-          }
-          case "socket": {
-            const trackedChild = this.socketChildren.get(child.id);
-            if (trackedChild !== void 0) {
-              trackedChild.count -= 1;
-              if (trackedChild.count === 0) {
-                this.socketChildren.delete(child.id);
-              } else {
-                this.socketChildren.set(child.id, trackedChild);
-              }
-            }
-            break;
+        const tracker = this.trackerMap[child.kind];
+        const trackedChild = tracker.getElementByKey(child.id);
+        if (trackedChild !== void 0) {
+          trackedChild.count -= 1;
+          if (trackedChild.count === 0) {
+            tracker.eraseElementByKey(child.id);
           }
         }
       }
       getChildLists() {
-        const channels2 = [];
-        for (const { ref } of this.channelChildren.values()) {
-          channels2.push(ref);
-        }
-        const subchannels2 = [];
-        for (const { ref } of this.subchannelChildren.values()) {
-          subchannels2.push(ref);
-        }
-        const sockets2 = [];
-        for (const { ref } of this.socketChildren.values()) {
-          sockets2.push(ref);
-        }
-        return { channels: channels2, subchannels: subchannels2, sockets: sockets2 };
+        return {
+          channels: this.channelChildren,
+          subchannels: this.subchannelChildren,
+          sockets: this.socketChildren
+        };
       }
     };
     exports2.ChannelzChildrenTracker = ChannelzChildrenTracker;
+    var ChannelzChildrenTrackerStub = class extends ChannelzChildrenTracker {
+      refChild() {
+      }
+      unrefChild() {
+      }
+    };
+    exports2.ChannelzChildrenTrackerStub = ChannelzChildrenTrackerStub;
     var ChannelzCallTracker = class {
       constructor() {
         this.callsStarted = 0;
@@ -49009,65 +49819,66 @@ var require_channelz = __commonJS({
       }
     };
     exports2.ChannelzCallTracker = ChannelzCallTracker;
-    var nextId = 1;
-    function getNextId() {
-      return nextId++;
-    }
-    var channels = [];
-    var subchannels = [];
-    var servers = [];
-    var sockets = [];
-    function registerChannelzChannel(name2, getInfo, channelzEnabled) {
-      const id = getNextId();
-      const ref = { id, name: name2, kind: "channel" };
-      if (channelzEnabled) {
-        channels[id] = { ref, getInfo };
-      }
-      return ref;
-    }
-    exports2.registerChannelzChannel = registerChannelzChannel;
-    function registerChannelzSubchannel(name2, getInfo, channelzEnabled) {
-      const id = getNextId();
-      const ref = { id, name: name2, kind: "subchannel" };
-      if (channelzEnabled) {
-        subchannels[id] = { ref, getInfo };
-      }
-      return ref;
-    }
-    exports2.registerChannelzSubchannel = registerChannelzSubchannel;
-    function registerChannelzServer(getInfo, channelzEnabled) {
-      const id = getNextId();
-      const ref = { id, kind: "server" };
-      if (channelzEnabled) {
-        servers[id] = { ref, getInfo };
-      }
-      return ref;
-    }
-    exports2.registerChannelzServer = registerChannelzServer;
-    function registerChannelzSocket(name2, getInfo, channelzEnabled) {
-      const id = getNextId();
-      const ref = { id, name: name2, kind: "socket" };
-      if (channelzEnabled) {
-        sockets[id] = { ref, getInfo };
-      }
-      return ref;
-    }
-    exports2.registerChannelzSocket = registerChannelzSocket;
-    function unregisterChannelzRef(ref) {
-      switch (ref.kind) {
-        case "channel":
-          delete channels[ref.id];
-          return;
-        case "subchannel":
-          delete subchannels[ref.id];
-          return;
-        case "server":
-          delete servers[ref.id];
-          return;
-        case "socket":
-          delete sockets[ref.id];
-          return;
+    var ChannelzCallTrackerStub = class extends ChannelzCallTracker {
+      addCallStarted() {
       }
+      addCallSucceeded() {
+      }
+      addCallFailed() {
+      }
+    };
+    exports2.ChannelzCallTrackerStub = ChannelzCallTrackerStub;
+    var entityMaps = {
+      [
+        "channel"
+        /* EntityTypes.channel */
+      ]: new ordered_map_1.OrderedMap(),
+      [
+        "subchannel"
+        /* EntityTypes.subchannel */
+      ]: new ordered_map_1.OrderedMap(),
+      [
+        "server"
+        /* EntityTypes.server */
+      ]: new ordered_map_1.OrderedMap(),
+      [
+        "socket"
+        /* EntityTypes.socket */
+      ]: new ordered_map_1.OrderedMap()
+    };
+    var generateRegisterFn = (kind) => {
+      let nextId = 1;
+      function getNextId() {
+        return nextId++;
+      }
+      const entityMap = entityMaps[kind];
+      return (name2, getInfo, channelzEnabled) => {
+        const id = getNextId();
+        const ref = { id, name: name2, kind };
+        if (channelzEnabled) {
+          entityMap.setElement(id, { ref, getInfo });
+        }
+        return ref;
+      };
+    };
+    exports2.registerChannelzChannel = generateRegisterFn(
+      "channel"
+      /* EntityTypes.channel */
+    );
+    exports2.registerChannelzSubchannel = generateRegisterFn(
+      "subchannel"
+      /* EntityTypes.subchannel */
+    );
+    exports2.registerChannelzServer = generateRegisterFn(
+      "server"
+      /* EntityTypes.server */
+    );
+    exports2.registerChannelzSocket = generateRegisterFn(
+      "socket"
+      /* EntityTypes.socket */
+    );
+    function unregisterChannelzRef(ref) {
+      entityMaps[ref.kind].eraseElementByKey(ref.id);
     }
     exports2.unregisterChannelzRef = unregisterChannelzRef;
     function parseIPv6Section(addressSection) {
@@ -49144,6 +49955,14 @@ var require_channelz = __commonJS({
     }
     function getChannelMessage(channelEntry) {
       const resolvedInfo = channelEntry.getInfo();
+      const channelRef = [];
+      const subchannelRef = [];
+      resolvedInfo.children.channels.forEach((el) => {
+        channelRef.push(channelRefToMessage(el[1].ref));
+      });
+      resolvedInfo.children.subchannels.forEach((el) => {
+        subchannelRef.push(subchannelRefToMessage(el[1].ref));
+      });
       return {
         ref: channelRefToMessage(channelEntry.ref),
         data: {
@@ -49155,13 +49974,16 @@ var require_channelz = __commonJS({
           last_call_started_timestamp: dateToProtoTimestamp(resolvedInfo.callTracker.lastCallStartedTimestamp),
           trace: resolvedInfo.trace.getTraceMessage()
         },
-        channel_ref: resolvedInfo.children.channels.map((ref) => channelRefToMessage(ref)),
-        subchannel_ref: resolvedInfo.children.subchannels.map((ref) => subchannelRefToMessage(ref))
+        channel_ref: channelRef,
+        subchannel_ref: subchannelRef
       };
     }
     function GetChannel(call, callback) {
-      const channelId = Number.parseInt(call.request.channel_id);
-      const channelEntry = channels[channelId];
+      const channelId = parseInt(call.request.channel_id, 10);
+      const channelEntry = entityMaps[
+        "channel"
+        /* EntityTypes.channel */
+      ].getElementByKey(channelId);
       if (channelEntry === void 0) {
         callback({
           code: constants_1.Status.NOT_FOUND,
@@ -49172,26 +49994,28 @@ var require_channelz = __commonJS({
       callback(null, { channel: getChannelMessage(channelEntry) });
     }
     function GetTopChannels(call, callback) {
-      const maxResults = Number.parseInt(call.request.max_results);
+      const maxResults = parseInt(call.request.max_results, 10) || DEFAULT_MAX_RESULTS;
       const resultList = [];
-      let i = Number.parseInt(call.request.start_channel_id);
-      for (; i < channels.length; i++) {
-        const channelEntry = channels[i];
-        if (channelEntry === void 0) {
-          continue;
-        }
-        resultList.push(getChannelMessage(channelEntry));
-        if (resultList.length >= maxResults) {
-          break;
-        }
+      const startId = parseInt(call.request.start_channel_id, 10);
+      const channelEntries = entityMaps[
+        "channel"
+        /* EntityTypes.channel */
+      ];
+      let i;
+      for (i = channelEntries.lowerBound(startId); !i.equals(channelEntries.end()) && resultList.length < maxResults; i = i.next()) {
+        resultList.push(getChannelMessage(i.pointer[1]));
       }
       callback(null, {
         channel: resultList,
-        end: i >= servers.length
+        end: i.equals(channelEntries.end())
       });
     }
     function getServerMessage(serverEntry) {
       const resolvedInfo = serverEntry.getInfo();
+      const listenSocket = [];
+      resolvedInfo.listenerChildren.sockets.forEach((el) => {
+        listenSocket.push(socketRefToMessage(el[1].ref));
+      });
       return {
         ref: serverRefToMessage(serverEntry.ref),
         data: {
@@ -49201,12 +50025,16 @@ var require_channelz = __commonJS({
           last_call_started_timestamp: dateToProtoTimestamp(resolvedInfo.callTracker.lastCallStartedTimestamp),
           trace: resolvedInfo.trace.getTraceMessage()
         },
-        listen_socket: resolvedInfo.listenerChildren.sockets.map((ref) => socketRefToMessage(ref))
+        listen_socket: listenSocket
       };
     }
     function GetServer(call, callback) {
-      const serverId = Number.parseInt(call.request.server_id);
-      const serverEntry = servers[serverId];
+      const serverId = parseInt(call.request.server_id, 10);
+      const serverEntries = entityMaps[
+        "server"
+        /* EntityTypes.server */
+      ];
+      const serverEntry = serverEntries.getElementByKey(serverId);
       if (serverEntry === void 0) {
         callback({
           code: constants_1.Status.NOT_FOUND,
@@ -49217,27 +50045,28 @@ var require_channelz = __commonJS({
       callback(null, { server: getServerMessage(serverEntry) });
     }
     function GetServers(call, callback) {
-      const maxResults = Number.parseInt(call.request.max_results);
+      const maxResults = parseInt(call.request.max_results, 10) || DEFAULT_MAX_RESULTS;
+      const startId = parseInt(call.request.start_server_id, 10);
+      const serverEntries = entityMaps[
+        "server"
+        /* EntityTypes.server */
+      ];
       const resultList = [];
-      let i = Number.parseInt(call.request.start_server_id);
-      for (; i < servers.length; i++) {
-        const serverEntry = servers[i];
-        if (serverEntry === void 0) {
-          continue;
-        }
-        resultList.push(getServerMessage(serverEntry));
-        if (resultList.length >= maxResults) {
-          break;
-        }
+      let i;
+      for (i = serverEntries.lowerBound(startId); !i.equals(serverEntries.end()) && resultList.length < maxResults; i = i.next()) {
+        resultList.push(getServerMessage(i.pointer[1]));
       }
       callback(null, {
         server: resultList,
-        end: i >= servers.length
+        end: i.equals(serverEntries.end())
       });
     }
     function GetSubchannel(call, callback) {
-      const subchannelId = Number.parseInt(call.request.subchannel_id);
-      const subchannelEntry = subchannels[subchannelId];
+      const subchannelId = parseInt(call.request.subchannel_id, 10);
+      const subchannelEntry = entityMaps[
+        "subchannel"
+        /* EntityTypes.subchannel */
+      ].getElementByKey(subchannelId);
       if (subchannelEntry === void 0) {
         callback({
           code: constants_1.Status.NOT_FOUND,
@@ -49246,6 +50075,10 @@ var require_channelz = __commonJS({
         return;
       }
       const resolvedInfo = subchannelEntry.getInfo();
+      const listenSocket = [];
+      resolvedInfo.children.sockets.forEach((el) => {
+        listenSocket.push(socketRefToMessage(el[1].ref));
+      });
       const subchannelMessage = {
         ref: subchannelRefToMessage(subchannelEntry.ref),
         data: {
@@ -49257,7 +50090,7 @@ var require_channelz = __commonJS({
           last_call_started_timestamp: dateToProtoTimestamp(resolvedInfo.callTracker.lastCallStartedTimestamp),
           trace: resolvedInfo.trace.getTraceMessage()
         },
-        socket_ref: resolvedInfo.children.sockets.map((ref) => socketRefToMessage(ref))
+        socket_ref: listenSocket
       };
       callback(null, { subchannel: subchannelMessage });
     }
@@ -49282,8 +50115,11 @@ var require_channelz = __commonJS({
     }
     function GetSocket(call, callback) {
       var _a, _b, _c, _d, _e;
-      const socketId = Number.parseInt(call.request.socket_id);
-      const socketEntry = sockets[socketId];
+      const socketId = parseInt(call.request.socket_id, 10);
+      const socketEntry = entityMaps[
+        "socket"
+        /* EntityTypes.socket */
+      ].getElementByKey(socketId);
       if (socketEntry === void 0) {
         callback({
           code: constants_1.Status.NOT_FOUND,
@@ -49326,8 +50162,11 @@ var require_channelz = __commonJS({
       callback(null, { socket: socketMessage });
     }
     function GetServerSockets(call, callback) {
-      const serverId = Number.parseInt(call.request.server_id);
-      const serverEntry = servers[serverId];
+      const serverId = parseInt(call.request.server_id, 10);
+      const serverEntry = entityMaps[
+        "server"
+        /* EntityTypes.server */
+      ].getElementByKey(serverId);
       if (serverEntry === void 0) {
         callback({
           code: constants_1.Status.NOT_FOUND,
@@ -49335,23 +50174,18 @@ var require_channelz = __commonJS({
         });
         return;
       }
-      const startId = Number.parseInt(call.request.start_socket_id);
-      const maxResults = Number.parseInt(call.request.max_results);
+      const startId = parseInt(call.request.start_socket_id, 10);
+      const maxResults = parseInt(call.request.max_results, 10) || DEFAULT_MAX_RESULTS;
       const resolvedInfo = serverEntry.getInfo();
-      const allSockets = resolvedInfo.sessionChildren.sockets.sort((ref1, ref2) => ref1.id - ref2.id);
+      const allSockets = resolvedInfo.sessionChildren.sockets;
       const resultList = [];
-      let i = 0;
-      for (; i < allSockets.length; i++) {
-        if (allSockets[i].id >= startId) {
-          resultList.push(socketRefToMessage(allSockets[i]));
-          if (resultList.length >= maxResults) {
-            break;
-          }
-        }
+      let i;
+      for (i = allSockets.lowerBound(startId); !i.equals(allSockets.end()) && resultList.length < maxResults; i = i.next()) {
+        resultList.push(socketRefToMessage(i.pointer[1].ref));
       }
       callback(null, {
         socket_ref: resultList,
-        end: i >= allSockets.length
+        end: i.equals(allSockets.end())
       });
     }
     function getChannelzHandlers() {
@@ -49431,9 +50265,6 @@ var require_subchannel = __commonJS({
         this.stateListeners = /* @__PURE__ */ new Set();
         this.refcount = 0;
         this.channelzEnabled = true;
-        this.callTracker = new channelz_1.ChannelzCallTracker();
-        this.childrenTracker = new channelz_1.ChannelzChildrenTracker();
-        this.streamTracker = new channelz_1.ChannelzCallTracker();
         const backoffOptions = {
           initialDelay: options["grpc.initial_reconnect_backoff_ms"],
           maxDelay: options["grpc.max_reconnect_backoff_ms"]
@@ -49446,12 +50277,18 @@ var require_subchannel = __commonJS({
         this.keepaliveTime = (_a = options["grpc.keepalive_time_ms"]) !== null && _a !== void 0 ? _a : -1;
         if (options["grpc.enable_channelz"] === 0) {
           this.channelzEnabled = false;
+          this.channelzTrace = new channelz_1.ChannelzTraceStub();
+          this.callTracker = new channelz_1.ChannelzCallTrackerStub();
+          this.childrenTracker = new channelz_1.ChannelzChildrenTrackerStub();
+          this.streamTracker = new channelz_1.ChannelzCallTrackerStub();
+        } else {
+          this.channelzTrace = new channelz_1.ChannelzTrace();
+          this.callTracker = new channelz_1.ChannelzCallTracker();
+          this.childrenTracker = new channelz_1.ChannelzChildrenTracker();
+          this.streamTracker = new channelz_1.ChannelzCallTracker();
         }
-        this.channelzTrace = new channelz_1.ChannelzTrace();
         this.channelzRef = (0, channelz_1.registerChannelzSubchannel)(this.subchannelAddressString, () => this.getChannelzInfo(), this.channelzEnabled);
-        if (this.channelzEnabled) {
-          this.channelzTrace.addTrace("CT_INFO", "Subchannel created");
-        }
+        this.channelzTrace.addTrace("CT_INFO", "Subchannel created");
         this.trace("Subchannel constructed with options " + JSON.stringify(options, void 0, 2));
       }
       getChannelzInfo() {
@@ -49574,12 +50411,8 @@ var require_subchannel = __commonJS({
         this.refTrace("refcount " + this.refcount + " -> " + (this.refcount - 1));
         this.refcount -= 1;
         if (this.refcount === 0) {
-          if (this.channelzEnabled) {
-            this.channelzTrace.addTrace("CT_INFO", "Shutting down");
-          }
-          if (this.channelzEnabled) {
-            (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
-          }
+          this.channelzTrace.addTrace("CT_INFO", "Shutting down");
+          (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
           process.nextTick(() => {
             this.transitionToState([connectivity_state_1.ConnectivityState.CONNECTING, connectivity_state_1.ConnectivityState.READY], connectivity_state_1.ConnectivityState.IDLE);
           });
@@ -49689,6 +50522,17 @@ var require_subchannel = __commonJS({
   }
 });
 
+// node_modules/@grpc/grpc-js/build/src/environment.js
+var require_environment13 = __commonJS({
+  "node_modules/@grpc/grpc-js/build/src/environment.js"(exports2) {
+    "use strict";
+    var _a;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.GRPC_NODE_USE_ALTERNATIVE_RESOLVER = void 0;
+    exports2.GRPC_NODE_USE_ALTERNATIVE_RESOLVER = ((_a = process.env.GRPC_NODE_USE_ALTERNATIVE_RESOLVER) !== null && _a !== void 0 ? _a : "false") === "true";
+  }
+});
+
 // node_modules/@grpc/grpc-js/build/src/resolver-dns.js
 var require_resolver_dns = __commonJS({
   "node_modules/@grpc/grpc-js/build/src/resolver-dns.js"(exports2) {
@@ -49696,8 +50540,7 @@ var require_resolver_dns = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.setup = exports2.DEFAULT_PORT = void 0;
     var resolver_1 = require_resolver();
-    var dns = __require("dns");
-    var util = __require("util");
+    var dns_1 = __require("dns");
     var service_config_1 = require_service_config();
     var constants_1 = require_constants8();
     var metadata_1 = require_metadata();
@@ -49706,14 +50549,13 @@ var require_resolver_dns = __commonJS({
     var uri_parser_1 = require_uri_parser();
     var net_1 = __require("net");
     var backoff_timeout_1 = require_backoff_timeout();
+    var environment_1 = require_environment13();
     var TRACER_NAME = "dns_resolver";
     function trace(text) {
       logging.trace(constants_2.LogVerbosity.DEBUG, TRACER_NAME, text);
     }
     exports2.DEFAULT_PORT = 443;
     var DEFAULT_MIN_TIME_BETWEEN_RESOLUTIONS_MS = 3e4;
-    var resolveTxtPromise = util.promisify(dns.resolveTxt);
-    var dnsLookupPromise = util.promisify(dns.lookup);
     var DnsResolver = class {
       constructor(target, listener, channelOptions) {
         var _a, _b, _c;
@@ -49728,7 +50570,11 @@ var require_resolver_dns = __commonJS({
         this.isNextResolutionTimerRunning = false;
         this.isServiceConfigEnabled = true;
         this.returnedIpResult = false;
+        this.alternativeResolver = new dns_1.promises.Resolver();
         trace("Resolver constructed for target " + (0, uri_parser_1.uriToString)(target));
+        if (target.authority) {
+          this.alternativeResolver.setServers([target.authority]);
+        }
         const hostPort = (0, uri_parser_1.splitHostPort)(target.path);
         if (hostPort === null) {
           this.ipResult = null;
@@ -49813,7 +50659,7 @@ var require_resolver_dns = __commonJS({
           trace("Looking up DNS hostname " + this.dnsHostname);
           this.latestLookupResult = null;
           const hostname = this.dnsHostname;
-          this.pendingLookupPromise = dnsLookupPromise(hostname, { all: true });
+          this.pendingLookupPromise = this.lookup(hostname);
           this.pendingLookupPromise.then((addressList) => {
             if (this.pendingLookupPromise === null) {
               return;
@@ -49821,11 +50667,10 @@ var require_resolver_dns = __commonJS({
             this.pendingLookupPromise = null;
             this.backoff.reset();
             this.backoff.stop();
-            const subchannelAddresses = addressList.map((addr) => ({ host: addr.address, port: +this.port }));
-            this.latestLookupResult = subchannelAddresses.map((address) => ({
+            this.latestLookupResult = addressList.map((address) => ({
               addresses: [address]
             }));
-            const allAddressesString = "[" + subchannelAddresses.map((addr) => addr.host + ":" + addr.port).join(",") + "]";
+            const allAddressesString = "[" + addressList.map((addr) => addr.host + ":" + addr.port).join(",") + "]";
             trace("Resolved addresses for target " + (0, uri_parser_1.uriToString)(this.target) + ": " + allAddressesString);
             if (this.latestLookupResult.length === 0) {
               this.listener.onError(this.defaultResolutionError);
@@ -49842,7 +50687,7 @@ var require_resolver_dns = __commonJS({
             this.listener.onError(this.defaultResolutionError);
           });
           if (this.isServiceConfigEnabled && this.pendingTxtPromise === null) {
-            this.pendingTxtPromise = resolveTxtPromise(hostname);
+            this.pendingTxtPromise = this.resolveTxt(hostname);
             this.pendingTxtPromise.then((txtRecord) => {
               if (this.pendingTxtPromise === null) {
                 return;
@@ -49865,15 +50710,43 @@ var require_resolver_dns = __commonJS({
           }
         }
       }
+      async lookup(hostname) {
+        if (environment_1.GRPC_NODE_USE_ALTERNATIVE_RESOLVER) {
+          trace("Using alternative DNS resolver.");
+          const records = await Promise.allSettled([
+            this.alternativeResolver.resolve4(hostname),
+            this.alternativeResolver.resolve6(hostname)
+          ]);
+          if (records.every((result) => result.status === "rejected")) {
+            throw new Error(records[0].reason);
+          }
+          return records.reduce((acc, result) => {
+            return result.status === "fulfilled" ? [...acc, ...result.value] : acc;
+          }, []).map((addr) => ({
+            host: addr,
+            port: +this.port
+          }));
+        }
+        const addressList = await dns_1.promises.lookup(hostname, { all: true });
+        return addressList.map((addr) => ({ host: addr.address, port: +this.port }));
+      }
+      async resolveTxt(hostname) {
+        if (environment_1.GRPC_NODE_USE_ALTERNATIVE_RESOLVER) {
+          trace("Using alternative DNS resolver.");
+          return this.alternativeResolver.resolveTxt(hostname);
+        }
+        return dns_1.promises.resolveTxt(hostname);
+      }
       startNextResolutionTimer() {
         var _a, _b;
         clearTimeout(this.nextResolutionTimer);
-        this.nextResolutionTimer = (_b = (_a = setTimeout(() => {
+        this.nextResolutionTimer = setTimeout(() => {
           this.stopNextResolutionTimer();
           if (this.continueResolving) {
             this.startResolutionWithBackoff();
           }
-        }, this.minTimeBetweenResolutionsMs)).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }, this.minTimeBetweenResolutionsMs);
+        (_b = (_a = this.nextResolutionTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
         this.isNextResolutionTimerRunning = true;
       }
       stopNextResolutionTimer() {
@@ -49986,7 +50859,7 @@ var require_http_proxy = __commonJS({
       if (proxyUrl.username) {
         if (proxyUrl.password) {
           (0, logging_1.log)(constants_1.LogVerbosity.INFO, "userinfo found in proxy URI");
-          userCred = `${proxyUrl.username}:${proxyUrl.password}`;
+          userCred = decodeURIComponent(`${proxyUrl.username}:${proxyUrl.password}`);
         } else {
           userCred = proxyUrl.username;
         }
@@ -50103,6 +50976,9 @@ var require_http_proxy = __commonJS({
           socket.removeAllListeners();
           if (res.statusCode === 200) {
             trace("Successfully connected to " + options.path + " through proxy " + proxyAddressString);
+            if (head.length > 0) {
+              socket.unshift(head);
+            }
             if ("secureContext" in connectionOptions) {
               const targetPath = (0, resolver_1.getDefaultAuthority)(parsedTarget);
               const hostPort2 = (0, uri_parser_1.splitHostPort)(targetPath);
@@ -50152,7 +51028,8 @@ var require_stream_decoder = __commonJS({
       ReadState2[ReadState2["READING_MESSAGE"] = 2] = "READING_MESSAGE";
     })(ReadState || (ReadState = {}));
     var StreamDecoder = class {
-      constructor() {
+      constructor(maxReadMessageLength) {
+        this.maxReadMessageLength = maxReadMessageLength;
         this.readState = ReadState.NO_DATA;
         this.readCompressFlag = Buffer.alloc(1);
         this.readPartialSize = Buffer.alloc(4);
@@ -50184,6 +51061,9 @@ var require_stream_decoder = __commonJS({
               readHead += toRead;
               if (this.readSizeRemaining === 0) {
                 this.readMessageSize = this.readPartialSize.readUInt32BE(0);
+                if (this.maxReadMessageLength !== -1 && this.readMessageSize > this.maxReadMessageLength) {
+                  throw new Error(`Received message larger than max (${this.readMessageSize} vs ${this.maxReadMessageLength})`);
+                }
                 this.readMessageRemaining = this.readMessageSize;
                 if (this.readMessageRemaining > 0) {
                   this.readState = ReadState.READING_MESSAGE;
@@ -50242,52 +51122,64 @@ var require_subchannel_call = __commonJS({
       }
       return "Unknown system error " + errno;
     }
+    function mapHttpStatusCode(code) {
+      const details = `Received HTTP status code ${code}`;
+      let mappedStatusCode;
+      switch (code) {
+        // TODO(murgatroid99): handle 100 and 101
+        case 400:
+          mappedStatusCode = constants_1.Status.INTERNAL;
+          break;
+        case 401:
+          mappedStatusCode = constants_1.Status.UNAUTHENTICATED;
+          break;
+        case 403:
+          mappedStatusCode = constants_1.Status.PERMISSION_DENIED;
+          break;
+        case 404:
+          mappedStatusCode = constants_1.Status.UNIMPLEMENTED;
+          break;
+        case 429:
+        case 502:
+        case 503:
+        case 504:
+          mappedStatusCode = constants_1.Status.UNAVAILABLE;
+          break;
+        default:
+          mappedStatusCode = constants_1.Status.UNKNOWN;
+      }
+      return {
+        code: mappedStatusCode,
+        details,
+        metadata: new metadata_1.Metadata()
+      };
+    }
     var Http2SubchannelCall = class {
       constructor(http2Stream, callEventTracker, listener, transport, callId) {
+        var _a;
         this.http2Stream = http2Stream;
         this.callEventTracker = callEventTracker;
         this.listener = listener;
         this.transport = transport;
         this.callId = callId;
-        this.decoder = new stream_decoder_1.StreamDecoder();
         this.isReadFilterPending = false;
         this.isPushPending = false;
         this.canPush = false;
         this.readsClosed = false;
         this.statusOutput = false;
         this.unpushedReadMessages = [];
-        this.mappedStatusCode = constants_1.Status.UNKNOWN;
         this.finalStatus = null;
         this.internalError = null;
+        this.serverEndedCall = false;
+        const maxReceiveMessageLength = (_a = transport.getOptions()["grpc.max_receive_message_length"]) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH;
+        this.decoder = new stream_decoder_1.StreamDecoder(maxReceiveMessageLength);
         http2Stream.on("response", (headers, flags) => {
           let headersString = "";
           for (const header of Object.keys(headers)) {
             headersString += "		" + header + ": " + headers[header] + "\n";
           }
           this.trace("Received server headers:\n" + headersString);
-          switch (headers[":status"]) {
-            // TODO(murgatroid99): handle 100 and 101
-            case 400:
-              this.mappedStatusCode = constants_1.Status.INTERNAL;
-              break;
-            case 401:
-              this.mappedStatusCode = constants_1.Status.UNAUTHENTICATED;
-              break;
-            case 403:
-              this.mappedStatusCode = constants_1.Status.PERMISSION_DENIED;
-              break;
-            case 404:
-              this.mappedStatusCode = constants_1.Status.UNIMPLEMENTED;
-              break;
-            case 429:
-            case 502:
-            case 503:
-            case 504:
-              this.mappedStatusCode = constants_1.Status.UNAVAILABLE;
-              break;
-            default:
-              this.mappedStatusCode = constants_1.Status.UNKNOWN;
-          }
+          this.httpStatusCode = headers[":status"];
           if (flags & http2.constants.NGHTTP2_FLAG_END_STREAM) {
             this.handleTrailers(headers);
           } else {
@@ -50313,7 +51205,13 @@ var require_subchannel_call = __commonJS({
             return;
           }
           this.trace("receive HTTP/2 data frame of length " + data.length);
-          const messages = this.decoder.write(data);
+          let messages;
+          try {
+            messages = this.decoder.write(data);
+          } catch (e) {
+            this.cancelWithStatus(constants_1.Status.RESOURCE_EXHAUSTED, e.message);
+            return;
+          }
           for (const message of messages) {
             this.trace("parsed message of length " + message.length);
             this.callEventTracker.addMessageReceived();
@@ -50325,10 +51223,11 @@ var require_subchannel_call = __commonJS({
           this.maybeOutputStatus();
         });
         http2Stream.on("close", () => {
+          this.serverEndedCall = true;
           process.nextTick(() => {
-            var _a;
+            var _a2;
             this.trace("HTTP/2 stream closed with code " + http2Stream.rstCode);
-            if (((_a = this.finalStatus) === null || _a === void 0 ? void 0 : _a.code) === constants_1.Status.OK) {
+            if (((_a2 = this.finalStatus) === null || _a2 === void 0 ? void 0 : _a2.code) === constants_1.Status.OK) {
               return;
             }
             let code;
@@ -50338,8 +51237,14 @@ var require_subchannel_call = __commonJS({
                 if (this.finalStatus !== null) {
                   return;
                 }
-                code = constants_1.Status.INTERNAL;
-                details = `Received RST_STREAM with code ${http2Stream.rstCode}`;
+                if (this.httpStatusCode && this.httpStatusCode !== 200) {
+                  const mappedStatus = mapHttpStatusCode(this.httpStatusCode);
+                  code = mappedStatus.code;
+                  details = mappedStatus.details;
+                } else {
+                  code = constants_1.Status.INTERNAL;
+                  details = `Received RST_STREAM with code ${http2Stream.rstCode} (Call ended without gRPC status)`;
+                }
                 break;
               case http2.constants.NGHTTP2_REFUSED_STREAM:
                 code = constants_1.Status.UNAVAILABLE;
@@ -50390,6 +51295,9 @@ var require_subchannel_call = __commonJS({
           this.callEventTracker.onStreamEnd(false);
         });
       }
+      getDeadlineInfo() {
+        return [`remote_addr=${this.getPeer()}`];
+      }
       onDisconnect() {
         this.endCall({
           code: constants_1.Status.UNAVAILABLE,
@@ -50453,6 +51361,7 @@ var require_subchannel_call = __commonJS({
         }
       }
       handleTrailers(headers) {
+        this.serverEndedCall = true;
         this.callEventTracker.onStreamEnd(true);
         let headersString = "";
         for (const header of Object.keys(headers)) {
@@ -50466,31 +51375,46 @@ var require_subchannel_call = __commonJS({
           metadata = new metadata_1.Metadata();
         }
         const metadataMap = metadata.getMap();
-        let code = this.mappedStatusCode;
-        if (code === constants_1.Status.UNKNOWN && typeof metadataMap["grpc-status"] === "string") {
+        let status;
+        if (typeof metadataMap["grpc-status"] === "string") {
           const receivedStatus = Number(metadataMap["grpc-status"]);
-          if (receivedStatus in constants_1.Status) {
-            code = receivedStatus;
-            this.trace("received status code " + receivedStatus + " from server");
-          }
+          this.trace("received status code " + receivedStatus + " from server");
           metadata.remove("grpc-status");
-        }
-        let details = "";
-        if (typeof metadataMap["grpc-message"] === "string") {
-          try {
-            details = decodeURI(metadataMap["grpc-message"]);
-          } catch (e) {
-            details = metadataMap["grpc-message"];
+          let details = "";
+          if (typeof metadataMap["grpc-message"] === "string") {
+            try {
+              details = decodeURI(metadataMap["grpc-message"]);
+            } catch (e) {
+              details = metadataMap["grpc-message"];
+            }
+            metadata.remove("grpc-message");
+            this.trace('received status details string "' + details + '" from server');
           }
-          metadata.remove("grpc-message");
-          this.trace('received status details string "' + details + '" from server');
+          status = {
+            code: receivedStatus,
+            details,
+            metadata
+          };
+        } else if (this.httpStatusCode) {
+          status = mapHttpStatusCode(this.httpStatusCode);
+          status.metadata = metadata;
+        } else {
+          status = {
+            code: constants_1.Status.UNKNOWN,
+            details: "No status information received",
+            metadata
+          };
         }
-        const status = { code, details, metadata };
         this.endCall(status);
       }
       destroyHttp2Stream() {
         var _a;
-        if (!this.http2Stream.destroyed) {
+        if (this.http2Stream.destroyed) {
+          return;
+        }
+        if (this.serverEndedCall) {
+          this.http2Stream.end();
+        } else {
           let code;
           if (((_a = this.finalStatus) === null || _a === void 0 ? void 0 : _a.code) === constants_1.Status.OK) {
             code = http2.constants.NGHTTP2_NO_ERROR;
@@ -50606,18 +51530,14 @@ var require_transport = __commonJS({
     var Http2Transport = class {
       constructor(session, subchannelAddress, options, remoteName) {
         this.session = session;
+        this.options = options;
         this.remoteName = remoteName;
-        this.keepaliveTimeMs = -1;
-        this.keepaliveTimeoutMs = KEEPALIVE_TIMEOUT_MS;
-        this.keepaliveTimerId = null;
+        this.keepaliveTimer = null;
         this.pendingSendKeepalivePing = false;
-        this.keepaliveTimeoutId = null;
-        this.keepaliveWithoutCalls = false;
         this.activeCalls = /* @__PURE__ */ new Set();
         this.disconnectListeners = [];
         this.disconnectHandled = false;
         this.channelzEnabled = true;
-        this.streamTracker = new channelz_1.ChannelzCallTracker();
         this.keepalivesSent = 0;
         this.messagesSent = 0;
         this.messagesReceived = 0;
@@ -50626,6 +51546,9 @@ var require_transport = __commonJS({
         this.subchannelAddressString = (0, subchannel_address_1.subchannelAddressToString)(subchannelAddress);
         if (options["grpc.enable_channelz"] === 0) {
           this.channelzEnabled = false;
+          this.streamTracker = new channelz_1.ChannelzCallTrackerStub();
+        } else {
+          this.streamTracker = new channelz_1.ChannelzCallTracker();
         }
         this.channelzRef = (0, channelz_1.registerChannelzSocket)(this.subchannelAddressString, () => this.getChannelzInfo(), this.channelzEnabled);
         this.userAgent = [
@@ -50635,9 +51558,13 @@ var require_transport = __commonJS({
         ].filter((e) => e).join(" ");
         if ("grpc.keepalive_time_ms" in options) {
           this.keepaliveTimeMs = options["grpc.keepalive_time_ms"];
+        } else {
+          this.keepaliveTimeMs = -1;
         }
         if ("grpc.keepalive_timeout_ms" in options) {
           this.keepaliveTimeoutMs = options["grpc.keepalive_timeout_ms"];
+        } else {
+          this.keepaliveTimeoutMs = KEEPALIVE_TIMEOUT_MS;
         }
         if ("grpc.keepalive_permit_without_calls" in options) {
           this.keepaliveWithoutCalls = options["grpc.keepalive_permit_without_calls"] === 1;
@@ -50646,7 +51573,6 @@ var require_transport = __commonJS({
         }
         session.once("close", () => {
           this.trace("session closed");
-          this.stopKeepalivePings();
           this.handleDisconnect();
         });
         session.once("goaway", (errorCode, lastStreamID, opaqueData) => {
@@ -50659,6 +51585,7 @@ var require_transport = __commonJS({
         });
         session.once("error", (error) => {
           this.trace("connection closed with error " + error.message);
+          this.handleDisconnect();
         });
         if (logging.isTracerEnabled(TRACER_NAME)) {
           session.on("remoteSettings", (settings) => {
@@ -50744,62 +51671,64 @@ var require_transport = __commonJS({
        * Handle connection drops, but not GOAWAYs.
        */
       handleDisconnect() {
+        if (this.disconnectHandled) {
+          return;
+        }
+        this.clearKeepaliveTimeout();
         this.reportDisconnectToOwner(false);
         setImmediate(() => {
           for (const call of this.activeCalls) {
             call.onDisconnect();
           }
+          this.session.destroy();
         });
       }
       addDisconnectListener(listener) {
         this.disconnectListeners.push(listener);
       }
-      clearKeepaliveTimer() {
-        if (!this.keepaliveTimerId) {
-          return;
-        }
-        clearTimeout(this.keepaliveTimerId);
-        this.keepaliveTimerId = null;
-      }
-      clearKeepaliveTimeout() {
-        if (!this.keepaliveTimeoutId) {
-          return;
-        }
-        clearTimeout(this.keepaliveTimeoutId);
-        this.keepaliveTimeoutId = null;
-      }
       canSendPing() {
-        return this.keepaliveTimeMs > 0 && (this.keepaliveWithoutCalls || this.activeCalls.size > 0);
+        return !this.session.destroyed && this.keepaliveTimeMs > 0 && (this.keepaliveWithoutCalls || this.activeCalls.size > 0);
       }
       maybeSendPing() {
         var _a, _b;
-        this.clearKeepaliveTimer();
         if (!this.canSendPing()) {
           this.pendingSendKeepalivePing = true;
           return;
         }
+        if (this.keepaliveTimer) {
+          console.error("keepaliveTimeout is not null");
+          return;
+        }
         if (this.channelzEnabled) {
           this.keepalivesSent += 1;
         }
         this.keepaliveTrace("Sending ping with timeout " + this.keepaliveTimeoutMs + "ms");
-        if (!this.keepaliveTimeoutId) {
-          this.keepaliveTimeoutId = setTimeout(() => {
-            this.keepaliveTrace("Ping timeout passed without response");
-            this.handleDisconnect();
-          }, this.keepaliveTimeoutMs);
-          (_b = (_a = this.keepaliveTimeoutId).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
+        this.keepaliveTimer = setTimeout(() => {
+          this.keepaliveTimer = null;
+          this.keepaliveTrace("Ping timeout passed without response");
+          this.handleDisconnect();
+        }, this.keepaliveTimeoutMs);
+        (_b = (_a = this.keepaliveTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        let pingSendError = "";
         try {
-          this.session.ping((err, duration, payload) => {
+          const pingSentSuccessfully = this.session.ping((err, duration, payload) => {
+            this.clearKeepaliveTimeout();
             if (err) {
               this.keepaliveTrace("Ping failed with error " + err.message);
               this.handleDisconnect();
+            } else {
+              this.keepaliveTrace("Received ping response");
+              this.maybeStartKeepalivePingTimer();
             }
-            this.keepaliveTrace("Received ping response");
-            this.clearKeepaliveTimeout();
-            this.maybeStartKeepalivePingTimer();
           });
+          if (!pingSentSuccessfully) {
+            pingSendError = "Ping returned false";
+          }
         } catch (e) {
+          pingSendError = (e instanceof Error ? e.message : "") || "Unknown error";
+        }
+        if (pingSendError) {
+          this.keepaliveTrace("Ping send failed: " + pingSendError);
           this.handleDisconnect();
         }
       }
@@ -50817,19 +51746,23 @@ var require_transport = __commonJS({
         if (this.pendingSendKeepalivePing) {
           this.pendingSendKeepalivePing = false;
           this.maybeSendPing();
-        } else if (!this.keepaliveTimerId && !this.keepaliveTimeoutId) {
+        } else if (!this.keepaliveTimer) {
           this.keepaliveTrace("Starting keepalive timer for " + this.keepaliveTimeMs + "ms");
-          this.keepaliveTimerId = (_b = (_a = setTimeout(() => {
+          this.keepaliveTimer = setTimeout(() => {
+            this.keepaliveTimer = null;
             this.maybeSendPing();
-          }, this.keepaliveTimeMs)).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+          }, this.keepaliveTimeMs);
+          (_b = (_a = this.keepaliveTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
         }
       }
-      stopKeepalivePings() {
-        if (this.keepaliveTimerId) {
-          clearTimeout(this.keepaliveTimerId);
-          this.keepaliveTimerId = null;
+      /**
+       * Clears whichever keepalive timeout is currently active, if any.
+       */
+      clearKeepaliveTimeout() {
+        if (this.keepaliveTimer) {
+          clearTimeout(this.keepaliveTimer);
+          this.keepaliveTimer = null;
         }
-        this.clearKeepaliveTimeout();
       }
       removeActiveCall(call) {
         this.activeCalls.delete(call);
@@ -50926,6 +51859,9 @@ var require_transport = __commonJS({
       getPeerName() {
         return this.subchannelAddressString;
       }
+      getOptions() {
+        return this.options;
+      }
       shutdown() {
         this.session.close();
         (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
@@ -50945,7 +51881,7 @@ var require_transport = __commonJS({
           return Promise.reject();
         }
         return new Promise((resolve, reject) => {
-          var _a, _b, _c;
+          var _a, _b, _c, _d;
           let remoteName;
           if (proxyConnectionResult.realTarget) {
             remoteName = (0, uri_parser_1.uriToString)(proxyConnectionResult.realTarget);
@@ -50967,12 +51903,13 @@ var require_transport = __commonJS({
             addressScheme = "https://";
             if (options["grpc.ssl_target_name_override"]) {
               const sslTargetNameOverride = options["grpc.ssl_target_name_override"];
+              const originalCheckServerIdentity = (_b = connectionOptions.checkServerIdentity) !== null && _b !== void 0 ? _b : tls_1.checkServerIdentity;
               connectionOptions.checkServerIdentity = (host, cert) => {
-                return (0, tls_1.checkServerIdentity)(sslTargetNameOverride, cert);
+                return originalCheckServerIdentity(sslTargetNameOverride, cert);
               };
               connectionOptions.servername = sslTargetNameOverride;
             } else {
-              const authorityHostname = (_c = (_b = (0, uri_parser_1.splitHostPort)(targetAuthority)) === null || _b === void 0 ? void 0 : _b.host) !== null && _c !== void 0 ? _c : "localhost";
+              const authorityHostname = (_d = (_c = (0, uri_parser_1.splitHostPort)(targetAuthority)) === null || _c === void 0 ? void 0 : _c.host) !== null && _d !== void 0 ? _d : "localhost";
               connectionOptions.servername = authorityHostname;
             }
             if (proxyConnectionResult.socket) {
@@ -50993,6 +51930,7 @@ var require_transport = __commonJS({
           const session = http2.connect(addressScheme + targetAuthority, connectionOptions);
           this.session = session;
           let errorMessage = "Failed to connect";
+          let reportedError = false;
           session.unref();
           session.once("connect", () => {
             session.removeAllListeners();
@@ -51002,17 +51940,24 @@ var require_transport = __commonJS({
           session.once("close", () => {
             this.session = null;
             setImmediate(() => {
-              reject(`${errorMessage} (${(/* @__PURE__ */ new Date()).toISOString()})`);
+              if (!reportedError) {
+                reportedError = true;
+                reject(`${errorMessage} (${(/* @__PURE__ */ new Date()).toISOString()})`);
+              }
             });
           });
           session.once("error", (error) => {
             errorMessage = error.message;
             this.trace("connection failed with error " + errorMessage);
+            if (!reportedError) {
+              reportedError = true;
+              reject(`${errorMessage} (${(/* @__PURE__ */ new Date()).toISOString()})`);
+            }
           });
         });
       }
       connect(address, credentials, options) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this.isShutdown) {
           return Promise.reject();
         }
@@ -51021,17 +51966,18 @@ var require_transport = __commonJS({
           connectionOptions.ALPNProtocols = ["h2"];
           if (options["grpc.ssl_target_name_override"]) {
             const sslTargetNameOverride = options["grpc.ssl_target_name_override"];
+            const originalCheckServerIdentity = (_a = connectionOptions.checkServerIdentity) !== null && _a !== void 0 ? _a : tls_1.checkServerIdentity;
             connectionOptions.checkServerIdentity = (host, cert) => {
-              return (0, tls_1.checkServerIdentity)(sslTargetNameOverride, cert);
+              return originalCheckServerIdentity(sslTargetNameOverride, cert);
             };
             connectionOptions.servername = sslTargetNameOverride;
           } else {
             if ("grpc.http_connect_target" in options) {
-              const targetPath = (0, resolver_1.getDefaultAuthority)((_a = (0, uri_parser_1.parseUri)(options["grpc.http_connect_target"])) !== null && _a !== void 0 ? _a : {
+              const targetPath = (0, resolver_1.getDefaultAuthority)((_b = (0, uri_parser_1.parseUri)(options["grpc.http_connect_target"])) !== null && _b !== void 0 ? _b : {
                 path: "localhost"
               });
               const hostPort = (0, uri_parser_1.splitHostPort)(targetPath);
-              connectionOptions.servername = (_b = hostPort === null || hostPort === void 0 ? void 0 : hostPort.host) !== null && _b !== void 0 ? _b : targetPath;
+              connectionOptions.servername = (_c = hostPort === null || hostPort === void 0 ? void 0 : hostPort.host) !== null && _c !== void 0 ? _c : targetPath;
             }
           }
           if (options["grpc-node.tls_enable_trace"]) {
@@ -51322,6 +52268,10 @@ var require_compression_filter = __commonJS({
       }
     };
     var DeflateHandler = class extends CompressionHandler {
+      constructor(maxRecvMessageLength) {
+        super();
+        this.maxRecvMessageLength = maxRecvMessageLength;
+      }
       compressMessage(message) {
         return new Promise((resolve, reject) => {
           zlib.deflate(message, (err, output) => {
@@ -51335,17 +52285,33 @@ var require_compression_filter = __commonJS({
       }
       decompressMessage(message) {
         return new Promise((resolve, reject) => {
-          zlib.inflate(message, (err, output) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(output);
+          let totalLength = 0;
+          const messageParts = [];
+          const decompresser = zlib.createInflate();
+          decompresser.on("data", (chunk) => {
+            messageParts.push(chunk);
+            totalLength += chunk.byteLength;
+            if (this.maxRecvMessageLength !== -1 && totalLength > this.maxRecvMessageLength) {
+              decompresser.destroy();
+              reject({
+                code: constants_1.Status.RESOURCE_EXHAUSTED,
+                details: `Received message that decompresses to a size larger than ${this.maxRecvMessageLength}`
+              });
             }
           });
+          decompresser.on("end", () => {
+            resolve(Buffer.concat(messageParts));
+          });
+          decompresser.write(message);
+          decompresser.end();
         });
       }
     };
     var GzipHandler = class extends CompressionHandler {
+      constructor(maxRecvMessageLength) {
+        super();
+        this.maxRecvMessageLength = maxRecvMessageLength;
+      }
       compressMessage(message) {
         return new Promise((resolve, reject) => {
           zlib.gzip(message, (err, output) => {
@@ -51359,13 +52325,25 @@ var require_compression_filter = __commonJS({
       }
       decompressMessage(message) {
         return new Promise((resolve, reject) => {
-          zlib.unzip(message, (err, output) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(output);
+          let totalLength = 0;
+          const messageParts = [];
+          const decompresser = zlib.createGunzip();
+          decompresser.on("data", (chunk) => {
+            messageParts.push(chunk);
+            totalLength += chunk.byteLength;
+            if (this.maxRecvMessageLength !== -1 && totalLength > this.maxRecvMessageLength) {
+              decompresser.destroy();
+              reject({
+                code: constants_1.Status.RESOURCE_EXHAUSTED,
+                details: `Received message that decompresses to a size larger than ${this.maxRecvMessageLength}`
+              });
             }
           });
+          decompresser.on("end", () => {
+            resolve(Buffer.concat(messageParts));
+          });
+          decompresser.write(message);
+          decompresser.end();
         });
       }
     };
@@ -51381,34 +52359,36 @@ var require_compression_filter = __commonJS({
         return Promise.reject(new Error(`Compression method not supported: ${this.compressionName}`));
       }
     };
-    function getCompressionHandler(compressionName) {
+    function getCompressionHandler(compressionName, maxReceiveMessageSize) {
       switch (compressionName) {
         case "identity":
           return new IdentityHandler();
         case "deflate":
-          return new DeflateHandler();
+          return new DeflateHandler(maxReceiveMessageSize);
         case "gzip":
-          return new GzipHandler();
+          return new GzipHandler(maxReceiveMessageSize);
         default:
           return new UnknownHandler(compressionName);
       }
     }
     var CompressionFilter = class extends filter_1.BaseFilter {
       constructor(channelOptions, sharedFilterConfig) {
-        var _a;
+        var _a, _b, _c;
         super();
         this.sharedFilterConfig = sharedFilterConfig;
         this.sendCompression = new IdentityHandler();
         this.receiveCompression = new IdentityHandler();
         this.currentCompressionAlgorithm = "identity";
         const compressionAlgorithmKey = channelOptions["grpc.default_compression_algorithm"];
+        this.maxReceiveMessageLength = (_a = channelOptions["grpc.max_receive_message_length"]) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH;
+        this.maxSendMessageLength = (_b = channelOptions["grpc.max_send_message_length"]) !== null && _b !== void 0 ? _b : constants_1.DEFAULT_MAX_SEND_MESSAGE_LENGTH;
         if (compressionAlgorithmKey !== void 0) {
           if (isCompressionAlgorithmKey(compressionAlgorithmKey)) {
             const clientSelectedEncoding = compression_algorithms_1.CompressionAlgorithms[compressionAlgorithmKey];
-            const serverSupportedEncodings = (_a = sharedFilterConfig.serverSupportedEncodingHeader) === null || _a === void 0 ? void 0 : _a.split(",");
+            const serverSupportedEncodings = (_c = sharedFilterConfig.serverSupportedEncodingHeader) === null || _c === void 0 ? void 0 : _c.split(",");
             if (!serverSupportedEncodings || serverSupportedEncodings.includes(clientSelectedEncoding)) {
               this.currentCompressionAlgorithm = clientSelectedEncoding;
-              this.sendCompression = getCompressionHandler(this.currentCompressionAlgorithm);
+              this.sendCompression = getCompressionHandler(this.currentCompressionAlgorithm, -1);
             }
           } else {
             logging.log(constants_1.LogVerbosity.ERROR, `Invalid value provided for grpc.default_compression_algorithm option: ${compressionAlgorithmKey}`);
@@ -51431,7 +52411,7 @@ var require_compression_filter = __commonJS({
         if (receiveEncoding.length > 0) {
           const encoding = receiveEncoding[0];
           if (typeof encoding === "string") {
-            this.receiveCompression = getCompressionHandler(encoding);
+            this.receiveCompression = getCompressionHandler(encoding, this.maxReceiveMessageLength);
           }
         }
         metadata.remove("grpc-encoding");
@@ -51450,6 +52430,12 @@ var require_compression_filter = __commonJS({
       async sendMessage(message) {
         var _a;
         const resolvedMessage = await message;
+        if (this.maxSendMessageLength !== -1 && resolvedMessage.message.length > this.maxSendMessageLength) {
+          throw {
+            code: constants_1.Status.RESOURCE_EXHAUSTED,
+            details: `Attempted to send message with a size larger than ${this.maxSendMessageLength}`
+          };
+        }
         let compress;
         if (this.sendCompression instanceof IdentityHandler) {
           compress = false;
@@ -51479,79 +52465,12 @@ var require_compression_filter = __commonJS({
   }
 });
 
-// node_modules/@grpc/grpc-js/build/src/max-message-size-filter.js
-var require_max_message_size_filter = __commonJS({
-  "node_modules/@grpc/grpc-js/build/src/max-message-size-filter.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.MaxMessageSizeFilterFactory = exports2.MaxMessageSizeFilter = void 0;
-    var filter_1 = require_filter();
-    var constants_1 = require_constants8();
-    var metadata_1 = require_metadata();
-    var MaxMessageSizeFilter = class extends filter_1.BaseFilter {
-      constructor(options) {
-        super();
-        this.maxSendMessageSize = constants_1.DEFAULT_MAX_SEND_MESSAGE_LENGTH;
-        this.maxReceiveMessageSize = constants_1.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH;
-        if ("grpc.max_send_message_length" in options) {
-          this.maxSendMessageSize = options["grpc.max_send_message_length"];
-        }
-        if ("grpc.max_receive_message_length" in options) {
-          this.maxReceiveMessageSize = options["grpc.max_receive_message_length"];
-        }
-      }
-      async sendMessage(message) {
-        if (this.maxSendMessageSize === -1) {
-          return message;
-        } else {
-          const concreteMessage = await message;
-          if (concreteMessage.message.length > this.maxSendMessageSize) {
-            throw {
-              code: constants_1.Status.RESOURCE_EXHAUSTED,
-              details: `Sent message larger than max (${concreteMessage.message.length} vs. ${this.maxSendMessageSize})`,
-              metadata: new metadata_1.Metadata()
-            };
-          } else {
-            return concreteMessage;
-          }
-        }
-      }
-      async receiveMessage(message) {
-        if (this.maxReceiveMessageSize === -1) {
-          return message;
-        } else {
-          const concreteMessage = await message;
-          if (concreteMessage.length > this.maxReceiveMessageSize) {
-            throw {
-              code: constants_1.Status.RESOURCE_EXHAUSTED,
-              details: `Received message larger than max (${concreteMessage.length} vs. ${this.maxReceiveMessageSize})`,
-              metadata: new metadata_1.Metadata()
-            };
-          } else {
-            return concreteMessage;
-          }
-        }
-      }
-    };
-    exports2.MaxMessageSizeFilter = MaxMessageSizeFilter;
-    var MaxMessageSizeFilterFactory = class {
-      constructor(options) {
-        this.options = options;
-      }
-      createFilter() {
-        return new MaxMessageSizeFilter(this.options);
-      }
-    };
-    exports2.MaxMessageSizeFilterFactory = MaxMessageSizeFilterFactory;
-  }
-});
-
 // node_modules/@grpc/grpc-js/build/src/deadline.js
 var require_deadline = __commonJS({
   "node_modules/@grpc/grpc-js/build/src/deadline.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.deadlineToString = exports2.getRelativeTimeout = exports2.getDeadlineTimeoutString = exports2.minDeadline = void 0;
+    exports2.formatDateDifference = exports2.deadlineToString = exports2.getRelativeTimeout = exports2.getDeadlineTimeoutString = exports2.minDeadline = void 0;
     function minDeadline(...deadlineList) {
       let minValue = Infinity;
       for (const deadline of deadlineList) {
@@ -51611,6 +52530,10 @@ var require_deadline = __commonJS({
       }
     }
     exports2.deadlineToString = deadlineToString;
+    function formatDateDifference(startDate, endDate) {
+      return ((endDate.getTime() - startDate.getTime()) / 1e3).toFixed(3) + "s";
+    }
+    exports2.formatDateDifference = formatDateDifference;
   }
 });
 
@@ -51679,6 +52602,7 @@ var require_load_balancing_call = __commonJS({
         this.metadata = null;
         this.listener = null;
         this.onCallEnded = null;
+        this.childStartTime = null;
         const splitPath = this.methodName.split("/");
         let serviceName = "";
         if (splitPath.length >= 2) {
@@ -51686,6 +52610,27 @@ var require_load_balancing_call = __commonJS({
         }
         const hostname = (_b = (_a = (0, uri_parser_1.splitHostPort)(this.host)) === null || _a === void 0 ? void 0 : _a.host) !== null && _b !== void 0 ? _b : "localhost";
         this.serviceUrl = `https://${hostname}/${serviceName}`;
+        this.startTime = /* @__PURE__ */ new Date();
+      }
+      getDeadlineInfo() {
+        var _a, _b;
+        const deadlineInfo = [];
+        if (this.childStartTime) {
+          if (this.childStartTime > this.startTime) {
+            if ((_a = this.metadata) === null || _a === void 0 ? void 0 : _a.getOptions().waitForReady) {
+              deadlineInfo.push("wait_for_ready");
+            }
+            deadlineInfo.push(`LB pick: ${(0, deadline_1.formatDateDifference)(this.startTime, this.childStartTime)}`);
+          }
+          deadlineInfo.push(...this.child.getDeadlineInfo());
+          return deadlineInfo;
+        } else {
+          if ((_b = this.metadata) === null || _b === void 0 ? void 0 : _b.getOptions().waitForReady) {
+            deadlineInfo.push("wait_for_ready");
+          }
+          deadlineInfo.push("Waiting for LB pick");
+        }
+        return deadlineInfo;
       }
       trace(text) {
         logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, "[" + this.callNumber + "] " + text);
@@ -51694,7 +52639,7 @@ var require_load_balancing_call = __commonJS({
         var _a, _b;
         if (!this.ended) {
           this.ended = true;
-          this.trace("ended with status: code=" + status.code + ' details="' + status.details + '"');
+          this.trace("ended with status: code=" + status.code + ' details="' + status.details + '" start time=' + this.startTime.toISOString());
           const finalStatus = Object.assign(Object.assign({}, status), { progress });
           (_a = this.listener) === null || _a === void 0 ? void 0 : _a.onReceiveStatus(finalStatus);
           (_b = this.onCallEnded) === null || _b === void 0 ? void 0 : _b.call(this, finalStatus.code);
@@ -51756,6 +52701,7 @@ var require_load_balancing_call = __commonJS({
                     }
                   }
                 });
+                this.childStartTime = /* @__PURE__ */ new Date();
               } catch (error) {
                 this.trace("Failed to start call on picked subchannel " + subchannelString + " with error " + error.message);
                 this.outputStatus({
@@ -51891,6 +52837,9 @@ var require_resolving_call = __commonJS({
         this.deadlineTimer = setTimeout(() => {
         }, 0);
         this.filterStack = null;
+        this.deadlineStartTime = null;
+        this.configReceivedTime = null;
+        this.childStartTime = null;
         this.deadline = options.deadline;
         this.host = options.host;
         if (options.parentCall) {
@@ -51912,12 +52861,37 @@ var require_resolving_call = __commonJS({
       }
       runDeadlineTimer() {
         clearTimeout(this.deadlineTimer);
+        this.deadlineStartTime = /* @__PURE__ */ new Date();
         this.trace("Deadline: " + (0, deadline_1.deadlineToString)(this.deadline));
         const timeout = (0, deadline_1.getRelativeTimeout)(this.deadline);
         if (timeout !== Infinity) {
           this.trace("Deadline will be reached in " + timeout + "ms");
           const handleDeadline = () => {
-            this.cancelWithStatus(constants_1.Status.DEADLINE_EXCEEDED, "Deadline exceeded");
+            if (!this.deadlineStartTime) {
+              this.cancelWithStatus(constants_1.Status.DEADLINE_EXCEEDED, "Deadline exceeded");
+              return;
+            }
+            const deadlineInfo = [];
+            const deadlineEndTime = /* @__PURE__ */ new Date();
+            deadlineInfo.push(`Deadline exceeded after ${(0, deadline_1.formatDateDifference)(this.deadlineStartTime, deadlineEndTime)}`);
+            if (this.configReceivedTime) {
+              if (this.configReceivedTime > this.deadlineStartTime) {
+                deadlineInfo.push(`name resolution: ${(0, deadline_1.formatDateDifference)(this.deadlineStartTime, this.configReceivedTime)}`);
+              }
+              if (this.childStartTime) {
+                if (this.childStartTime > this.configReceivedTime) {
+                  deadlineInfo.push(`metadata filters: ${(0, deadline_1.formatDateDifference)(this.configReceivedTime, this.childStartTime)}`);
+                }
+              } else {
+                deadlineInfo.push("waiting for metadata filters");
+              }
+            } else {
+              deadlineInfo.push("waiting for name resolution");
+            }
+            if (this.child) {
+              deadlineInfo.push(...this.child.getDeadlineInfo());
+            }
+            this.cancelWithStatus(constants_1.Status.DEADLINE_EXCEEDED, deadlineInfo.join(","));
           };
           if (timeout <= 0) {
             process.nextTick(handleDeadline);
@@ -51977,6 +52951,7 @@ var require_resolving_call = __commonJS({
           }
           return;
         }
+        this.configReceivedTime = /* @__PURE__ */ new Date();
         const config = configResult.config;
         if (config.status !== constants_1.Status.OK) {
           const { code, details } = (0, control_plane_status_1.restrictControlPlaneStatusCode)(config.status, "Failed to route call to method " + this.method);
@@ -51999,6 +52974,7 @@ var require_resolving_call = __commonJS({
         this.filterStack.sendMetadata(Promise.resolve(this.metadata)).then((filteredMetadata) => {
           this.child = this.channel.createInnerCall(config, this.method, this.host, this.credentials, this.deadline);
           this.trace("Created child [" + this.child.getCallNumber() + "]");
+          this.childStartTime = /* @__PURE__ */ new Date();
           this.child.start(filteredMetadata, {
             onReceiveMetadata: (metadata) => {
               this.trace("Received metadata");
@@ -52112,6 +53088,7 @@ var require_retrying_call = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.RetryingCall = exports2.MessageBufferTracker = exports2.RetryThrottler = void 0;
     var constants_1 = require_constants8();
+    var deadline_1 = require_deadline();
     var metadata_1 = require_metadata();
     var logging = require_logging();
     var TRACER_NAME = "retrying_call";
@@ -52177,8 +53154,10 @@ var require_retrying_call = __commonJS({
     };
     exports2.MessageBufferTracker = MessageBufferTracker;
     var PREVIONS_RPC_ATTEMPTS_METADATA_KEY = "grpc-previous-rpc-attempts";
+    var DEFAULT_MAX_ATTEMPTS_LIMIT = 5;
     var RetryingCall = class {
       constructor(channel, callConfig, methodName, host, credentials, deadline, callNumber, bufferTracker, retryThrottler) {
+        var _a;
         this.channel = channel;
         this.callConfig = callConfig;
         this.methodName = methodName;
@@ -52200,15 +53179,35 @@ var require_retrying_call = __commonJS({
         this.committedCallIndex = null;
         this.initialRetryBackoffSec = 0;
         this.nextRetryBackoffSec = 0;
+        const maxAttemptsLimit = (_a = channel.getOptions()["grpc-node.retry_max_attempts_limit"]) !== null && _a !== void 0 ? _a : DEFAULT_MAX_ATTEMPTS_LIMIT;
         if (callConfig.methodConfig.retryPolicy) {
           this.state = "RETRY";
           const retryPolicy = callConfig.methodConfig.retryPolicy;
           this.nextRetryBackoffSec = this.initialRetryBackoffSec = Number(retryPolicy.initialBackoff.substring(0, retryPolicy.initialBackoff.length - 1));
+          this.maxAttempts = Math.min(retryPolicy.maxAttempts, maxAttemptsLimit);
         } else if (callConfig.methodConfig.hedgingPolicy) {
           this.state = "HEDGING";
+          this.maxAttempts = Math.min(callConfig.methodConfig.hedgingPolicy.maxAttempts, maxAttemptsLimit);
         } else {
           this.state = "TRANSPARENT_ONLY";
+          this.maxAttempts = 1;
+        }
+        this.startTime = /* @__PURE__ */ new Date();
+      }
+      getDeadlineInfo() {
+        if (this.underlyingCalls.length === 0) {
+          return [];
+        }
+        const deadlineInfo = [];
+        const latestCall = this.underlyingCalls[this.underlyingCalls.length - 1];
+        if (this.underlyingCalls.length > 1) {
+          deadlineInfo.push(`previous attempts: ${this.underlyingCalls.length - 1}`);
         }
+        if (latestCall.startTime > this.startTime) {
+          deadlineInfo.push(`time to current attempt start: ${(0, deadline_1.formatDateDifference)(this.startTime, latestCall.startTime)}`);
+        }
+        deadlineInfo.push(...latestCall.call.getDeadlineInfo());
+        return deadlineInfo;
       }
       getCallNumber() {
         return this.callNumber;
@@ -52217,7 +53216,7 @@ var require_retrying_call = __commonJS({
         logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, "[" + this.callNumber + "] " + text);
       }
       reportStatus(statusObject) {
-        this.trace("ended with status: code=" + statusObject.code + ' details="' + statusObject.details + '"');
+        this.trace("ended with status: code=" + statusObject.code + ' details="' + statusObject.details + '" start time=' + this.startTime.toISOString());
         this.bufferTracker.freeAll(this.callNumber);
         this.writeBufferOffset = this.writeBufferOffset + this.writeBuffer.length;
         this.writeBuffer = [];
@@ -52309,7 +53308,10 @@ var require_retrying_call = __commonJS({
         }
       }
       isStatusCodeInList(list, code) {
-        return list.some((value) => value === code || value.toString().toLowerCase() === constants_1.Status[code].toLowerCase());
+        return list.some((value) => {
+          var _a;
+          return value === code || value.toString().toLowerCase() === ((_a = constants_1.Status[code]) === null || _a === void 0 ? void 0 : _a.toLowerCase());
+        });
       }
       getNextRetryBackoffMs() {
         var _a;
@@ -52327,8 +53329,7 @@ var require_retrying_call = __commonJS({
           callback(false);
           return;
         }
-        const retryPolicy = this.callConfig.methodConfig.retryPolicy;
-        if (this.attempts >= Math.min(retryPolicy.maxAttempts, 5)) {
+        if (this.attempts >= this.maxAttempts) {
           callback(false);
           return;
         }
@@ -52472,8 +53473,7 @@ var require_retrying_call = __commonJS({
         if (!this.callConfig.methodConfig.hedgingPolicy) {
           return;
         }
-        const hedgingPolicy = this.callConfig.methodConfig.hedgingPolicy;
-        if (this.attempts >= Math.min(hedgingPolicy.maxAttempts, 5)) {
+        if (this.attempts >= this.maxAttempts) {
           return;
         }
         this.attempts += 1;
@@ -52492,7 +53492,7 @@ var require_retrying_call = __commonJS({
           return;
         }
         const hedgingPolicy = this.callConfig.methodConfig.hedgingPolicy;
-        if (this.attempts >= Math.min(hedgingPolicy.maxAttempts, 5)) {
+        if (this.attempts >= this.maxAttempts) {
           return;
         }
         const hedgingDelayString = (_a = hedgingPolicy.hedgingDelay) !== null && _a !== void 0 ? _a : "0s";
@@ -52509,7 +53509,8 @@ var require_retrying_call = __commonJS({
         this.underlyingCalls.push({
           state: "ACTIVE",
           call: child,
-          nextMessageToSend: 0
+          nextMessageToSend: 0,
+          startTime: /* @__PURE__ */ new Date()
         });
         const previousAttempts = this.attempts - 1;
         const initialMetadata = this.initialMetadata.clone();
@@ -52755,12 +53756,12 @@ var require_internal_channel = __commonJS({
     var resolving_load_balancer_1 = require_resolving_load_balancer();
     var subchannel_pool_1 = require_subchannel_pool();
     var picker_1 = require_picker();
+    var metadata_1 = require_metadata();
     var constants_1 = require_constants8();
     var filter_stack_1 = require_filter_stack();
     var compression_filter_1 = require_compression_filter();
     var resolver_1 = require_resolver();
     var logging_1 = require_logging();
-    var max_message_size_filter_1 = require_max_message_size_filter();
     var http_proxy_1 = require_http_proxy();
     var uri_parser_1 = require_uri_parser();
     var connectivity_state_1 = require_connectivity_state();
@@ -52801,6 +53802,21 @@ var require_internal_channel = __commonJS({
         }
       }
     };
+    var ShutdownPicker = class {
+      pick(pickArgs) {
+        return {
+          pickResultType: picker_1.PickResultType.DROP,
+          status: {
+            code: constants_1.Status.UNAVAILABLE,
+            details: "Channel closed before call started",
+            metadata: new metadata_1.Metadata()
+          },
+          subchannel: null,
+          onCallStarted: null,
+          onCallEnded: null
+        };
+      }
+    };
     var InternalChannel = class {
       constructor(target, credentials, options) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -52941,12 +53957,13 @@ var require_internal_channel = __commonJS({
           }
         });
         this.filterStackFactory = new filter_stack_1.FilterStackFactory([
-          new max_message_size_filter_1.MaxMessageSizeFilterFactory(this.options),
           new compression_filter_1.CompressionFilterFactory(this, this.options)
         ]);
         this.trace("Channel constructed with options " + JSON.stringify(options, void 0, 2));
         const error = new Error();
-        (0, logging_1.trace)(constants_1.LogVerbosity.DEBUG, "channel_stacktrace", "(" + this.channelzRef.id + ") Channel constructed \n" + ((_h = error.stack) === null || _h === void 0 ? void 0 : _h.substring(error.stack.indexOf("\n") + 1)));
+        if ((0, logging_1.isTracerEnabled)("channel_stacktrace")) {
+          (0, logging_1.trace)(constants_1.LogVerbosity.DEBUG, "channel_stacktrace", "(" + this.channelzRef.id + ") Channel constructed \n" + ((_h = error.stack) === null || _h === void 0 ? void 0 : _h.substring(error.stack.indexOf("\n") + 1)));
+        }
         this.lastActivityTimestamp = /* @__PURE__ */ new Date();
       }
       getChannelzInfo() {
@@ -53023,7 +54040,9 @@ var require_internal_channel = __commonJS({
         this.callRefTimerRef();
       }
       getConfig(method, metadata) {
-        this.resolvingLoadBalancer.exitIdle();
+        if (this.connectivityState !== connectivity_state_1.ConnectivityState.SHUTDOWN) {
+          this.resolvingLoadBalancer.exitIdle();
+        }
         if (this.configSelector) {
           return {
             type: "SUCCESS",
@@ -53132,6 +54151,15 @@ var require_internal_channel = __commonJS({
       close() {
         this.resolvingLoadBalancer.destroy();
         this.updateState(connectivity_state_1.ConnectivityState.SHUTDOWN);
+        this.currentPicker = new ShutdownPicker();
+        for (const call of this.configSelectionQueue) {
+          call.cancelWithStatus(constants_1.Status.UNAVAILABLE, "Channel closed before call started");
+        }
+        this.configSelectionQueue = [];
+        for (const call of this.pickQueue) {
+          call.cancelWithStatus(constants_1.Status.UNAVAILABLE, "Channel closed before call started");
+        }
+        this.pickQueue = [];
         clearInterval(this.callRefTimer);
         if (this.idleTimer) {
           clearTimeout(this.idleTimer);
@@ -53197,6 +54225,9 @@ var require_internal_channel = __commonJS({
         }
         return this.createResolvingCall(method, deadline, host, parentCall, propagateFlags);
       }
+      getOptions() {
+        return this.options;
+      }
     };
     exports2.InternalChannel = InternalChannel;
   }
@@ -53306,6 +54337,9 @@ var require_server_call = __commonJS({
       getPath() {
         return this.path;
       }
+      getHost() {
+        return this.call.getHost();
+      }
     };
     exports2.ServerUnaryCallImpl = ServerUnaryCallImpl;
     var ServerReadableStreamImpl = class extends stream_1.Readable {
@@ -53331,6 +54365,9 @@ var require_server_call = __commonJS({
       getPath() {
         return this.path;
       }
+      getHost() {
+        return this.call.getHost();
+      }
     };
     exports2.ServerReadableStreamImpl = ServerReadableStreamImpl;
     var ServerWritableStreamImpl = class extends stream_1.Writable {
@@ -53363,13 +54400,16 @@ var require_server_call = __commonJS({
       getPath() {
         return this.path;
       }
+      getHost() {
+        return this.call.getHost();
+      }
       _write(chunk, encoding, callback) {
         this.call.sendMessage(chunk, callback);
       }
       _final(callback) {
         var _a;
-        this.call.sendStatus(Object.assign(Object.assign({}, this.pendingStatus), { metadata: (_a = this.pendingStatus.metadata) !== null && _a !== void 0 ? _a : this.trailingMetadata }));
         callback(null);
+        this.call.sendStatus(Object.assign(Object.assign({}, this.pendingStatus), { metadata: (_a = this.pendingStatus.metadata) !== null && _a !== void 0 ? _a : this.trailingMetadata }));
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       end(metadata) {
@@ -53409,6 +54449,9 @@ var require_server_call = __commonJS({
       getPath() {
         return this.path;
       }
+      getHost() {
+        return this.call.getHost();
+      }
       _read(size) {
         this.call.startRead();
       }
@@ -53417,8 +54460,8 @@ var require_server_call = __commonJS({
       }
       _final(callback) {
         var _a;
-        this.call.sendStatus(Object.assign(Object.assign({}, this.pendingStatus), { metadata: (_a = this.pendingStatus.metadata) !== null && _a !== void 0 ? _a : this.trailingMetadata }));
         callback(null);
+        this.call.sendStatus(Object.assign(Object.assign({}, this.pendingStatus), { metadata: (_a = this.pendingStatus.metadata) !== null && _a !== void 0 ? _a : this.trailingMetadata }));
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       end(metadata) {
@@ -53437,9 +54480,35 @@ var require_server_credentials = __commonJS({
   "node_modules/@grpc/grpc-js/build/src/server-credentials.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ServerCredentials = void 0;
+    exports2.createServerCredentialsWithInterceptors = exports2.ServerCredentials = void 0;
     var tls_helpers_1 = require_tls_helpers();
     var ServerCredentials = class {
+      constructor() {
+        this.watchers = /* @__PURE__ */ new Set();
+        this.latestContextOptions = null;
+      }
+      _addWatcher(watcher) {
+        this.watchers.add(watcher);
+      }
+      _removeWatcher(watcher) {
+        this.watchers.delete(watcher);
+      }
+      updateSecureContextOptions(options) {
+        if (options) {
+          this.latestContextOptions = options;
+        } else {
+          this.latestContextOptions = null;
+        }
+        for (const watcher of this.watchers) {
+          watcher(this.latestContextOptions);
+        }
+      }
+      _getSettings() {
+        return this.latestContextOptions;
+      }
+      _getInterceptors() {
+        return [];
+      }
       static createInsecure() {
         return new InsecureServerCredentials();
       }
@@ -53574,6 +54643,46 @@ var require_server_credentials = __commonJS({
         return true;
       }
     };
+    var InterceptorServerCredentials = class _InterceptorServerCredentials extends ServerCredentials {
+      constructor(childCredentials, interceptors) {
+        super();
+        this.childCredentials = childCredentials;
+        this.interceptors = interceptors;
+      }
+      _isSecure() {
+        return this.childCredentials._isSecure();
+      }
+      _equals(other) {
+        if (!(other instanceof _InterceptorServerCredentials)) {
+          return false;
+        }
+        if (!this.childCredentials._equals(other.childCredentials)) {
+          return false;
+        }
+        if (this.interceptors.length !== other.interceptors.length) {
+          return false;
+        }
+        for (let i = 0; i < this.interceptors.length; i++) {
+          if (this.interceptors[i] !== other.interceptors[i]) {
+            return false;
+          }
+        }
+        return true;
+      }
+      _getInterceptors() {
+        return this.interceptors;
+      }
+      _addWatcher(watcher) {
+        this.childCredentials._addWatcher(watcher);
+      }
+      _removeWatcher(watcher) {
+        this.childCredentials._removeWatcher(watcher);
+      }
+    };
+    function createServerCredentialsWithInterceptors(credentials, interceptors) {
+      return new InterceptorServerCredentials(credentials, interceptors);
+    }
+    exports2.createServerCredentialsWithInterceptors = createServerCredentialsWithInterceptors;
   }
 });
 
@@ -53588,11 +54697,8 @@ var require_server_interceptors = __commonJS({
     var http2 = __require("http2");
     var error_1 = require_error();
     var zlib = __require("zlib");
-    var util_1 = __require("util");
     var stream_decoder_1 = require_stream_decoder();
     var logging = require_logging();
-    var unzip = (0, util_1.promisify)(zlib.unzip);
-    var inflate = (0, util_1.promisify)(zlib.inflate);
     var TRACER_NAME = "server_call";
     function trace(text) {
       logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, text);
@@ -53775,13 +54881,19 @@ var require_server_interceptors = __commonJS({
     };
     var ServerInterceptingCall = class {
       constructor(nextCall, responder) {
+        var _a, _b, _c, _d;
         this.nextCall = nextCall;
         this.processingMetadata = false;
         this.processingMessage = false;
         this.pendingMessage = null;
         this.pendingMessageCallback = null;
         this.pendingStatus = null;
-        this.responder = Object.assign(Object.assign({}, defaultResponder), responder);
+        this.responder = {
+          start: (_a = responder === null || responder === void 0 ? void 0 : responder.start) !== null && _a !== void 0 ? _a : defaultResponder.start,
+          sendMetadata: (_b = responder === null || responder === void 0 ? void 0 : responder.sendMetadata) !== null && _b !== void 0 ? _b : defaultResponder.sendMetadata,
+          sendMessage: (_c = responder === null || responder === void 0 ? void 0 : responder.sendMessage) !== null && _c !== void 0 ? _c : defaultResponder.sendMessage,
+          sendStatus: (_d = responder === null || responder === void 0 ? void 0 : responder.sendStatus) !== null && _d !== void 0 ? _d : defaultResponder.sendStatus
+        };
       }
       processPendingMessage() {
         if (this.pendingMessageCallback) {
@@ -53798,7 +54910,13 @@ var require_server_interceptors = __commonJS({
       }
       start(listener) {
         this.responder.start((interceptedListener) => {
-          const fullInterceptedListener = Object.assign(Object.assign({}, defaultServerListener), interceptedListener);
+          var _a, _b, _c, _d;
+          const fullInterceptedListener = {
+            onReceiveMetadata: (_a = interceptedListener === null || interceptedListener === void 0 ? void 0 : interceptedListener.onReceiveMetadata) !== null && _a !== void 0 ? _a : defaultServerListener.onReceiveMetadata,
+            onReceiveMessage: (_b = interceptedListener === null || interceptedListener === void 0 ? void 0 : interceptedListener.onReceiveMessage) !== null && _b !== void 0 ? _b : defaultServerListener.onReceiveMessage,
+            onReceiveHalfClose: (_c = interceptedListener === null || interceptedListener === void 0 ? void 0 : interceptedListener.onReceiveHalfClose) !== null && _c !== void 0 ? _c : defaultServerListener.onReceiveHalfClose,
+            onCancel: (_d = interceptedListener === null || interceptedListener === void 0 ? void 0 : interceptedListener.onCancel) !== null && _d !== void 0 ? _d : defaultServerListener.onCancel
+          };
           const finalInterceptingListener = new InterceptingServerListenerImpl(fullInterceptedListener, listener);
           this.nextCall.start(finalInterceptingListener);
         });
@@ -53842,6 +54960,9 @@ var require_server_interceptors = __commonJS({
       getDeadline() {
         return this.nextCall.getDeadline();
       }
+      getHost() {
+        return this.nextCall.getHost();
+      }
     };
     exports2.ServerInterceptingCall = ServerInterceptingCall;
     var GRPC_ACCEPT_ENCODING_HEADER = "grpc-accept-encoding";
@@ -53873,6 +54994,7 @@ var require_server_interceptors = __commonJS({
     };
     var BaseServerInterceptingCall = class {
       constructor(stream, headers, callEventTracker, handler, options) {
+        var _a;
         this.stream = stream;
         this.callEventTracker = callEventTracker;
         this.handler = handler;
@@ -53886,7 +55008,6 @@ var require_server_interceptors = __commonJS({
         this.wantTrailers = false;
         this.cancelNotified = false;
         this.incomingEncoding = "identity";
-        this.decoder = new stream_decoder_1.StreamDecoder();
         this.readQueue = [];
         this.isReadPending = false;
         this.receivedHalfClose = false;
@@ -53894,8 +55015,8 @@ var require_server_interceptors = __commonJS({
         this.stream.once("error", (err) => {
         });
         this.stream.once("close", () => {
-          var _a;
-          trace("Request to method " + ((_a = this.handler) === null || _a === void 0 ? void 0 : _a.path) + " stream closed with rstCode " + this.stream.rstCode);
+          var _a2;
+          trace("Request to method " + ((_a2 = this.handler) === null || _a2 === void 0 ? void 0 : _a2.path) + " stream closed with rstCode " + this.stream.rstCode);
           if (this.callEventTracker && !this.streamEnded) {
             this.streamEnded = true;
             this.callEventTracker.onStreamEnd(false);
@@ -53920,6 +55041,8 @@ var require_server_interceptors = __commonJS({
         if ("grpc.max_receive_message_length" in options) {
           this.maxReceiveMessageSize = options["grpc.max_receive_message_length"];
         }
+        this.host = (_a = headers[":authority"]) !== null && _a !== void 0 ? _a : headers.host;
+        this.decoder = new stream_decoder_1.StreamDecoder(this.maxReceiveMessageSize);
         const metadata = metadata_1.Metadata.fromHttp2Headers(headers);
         if (logging.isTracerEnabled(TRACER_NAME)) {
           trace("Request to " + this.handler.path + " received headers " + JSON.stringify(metadata.toJSON()));
@@ -54012,18 +55135,41 @@ var require_server_interceptors = __commonJS({
         return output;
       }
       decompressMessage(message, encoding) {
-        switch (encoding) {
-          case "deflate":
-            return inflate(message.subarray(5));
-          case "gzip":
-            return unzip(message.subarray(5));
-          case "identity":
-            return message.subarray(5);
-          default:
-            return Promise.reject({
-              code: constants_1.Status.UNIMPLEMENTED,
-              details: `Received message compressed with unsupported encoding "${encoding}"`
+        const messageContents = message.subarray(5);
+        if (encoding === "identity") {
+          return messageContents;
+        } else if (encoding === "deflate" || encoding === "gzip") {
+          let decompresser;
+          if (encoding === "deflate") {
+            decompresser = zlib.createInflate();
+          } else {
+            decompresser = zlib.createGunzip();
+          }
+          return new Promise((resolve, reject) => {
+            let totalLength = 0;
+            const messageParts = [];
+            decompresser.on("data", (chunk) => {
+              messageParts.push(chunk);
+              totalLength += chunk.byteLength;
+              if (this.maxReceiveMessageSize !== -1 && totalLength > this.maxReceiveMessageSize) {
+                decompresser.destroy();
+                reject({
+                  code: constants_1.Status.RESOURCE_EXHAUSTED,
+                  details: `Received message that decompresses to a size larger than ${this.maxReceiveMessageSize}`
+                });
+              }
+            });
+            decompresser.on("end", () => {
+              resolve(Buffer.concat(messageParts));
             });
+            decompresser.write(messageContents);
+            decompresser.end();
+          });
+        } else {
+          return Promise.reject({
+            code: constants_1.Status.UNIMPLEMENTED,
+            details: `Received message compressed with unsupported encoding "${encoding}"`
+          });
         }
       }
       async decompressAndMaybePush(queueEntry) {
@@ -54032,7 +55178,13 @@ var require_server_interceptors = __commonJS({
         }
         const compressed = queueEntry.compressedMessage.readUInt8(0) === 1;
         const compressedMessageEncoding = compressed ? this.incomingEncoding : "identity";
-        const decompressedMessage = await this.decompressMessage(queueEntry.compressedMessage, compressedMessageEncoding);
+        let decompressedMessage;
+        try {
+          decompressedMessage = await this.decompressMessage(queueEntry.compressedMessage, compressedMessageEncoding);
+        } catch (err) {
+          this.sendStatus(err);
+          return;
+        }
         try {
           queueEntry.parsedMessage = this.handler.deserialize(decompressedMessage);
         } catch (err) {
@@ -54062,17 +55214,15 @@ var require_server_interceptors = __commonJS({
           return;
         }
         trace("Request to " + this.handler.path + " received data frame of size " + data.length);
-        const rawMessages = this.decoder.write(data);
+        let rawMessages;
+        try {
+          rawMessages = this.decoder.write(data);
+        } catch (e) {
+          this.sendStatus({ code: constants_1.Status.RESOURCE_EXHAUSTED, details: e.message });
+          return;
+        }
         for (const messageBytes of rawMessages) {
           this.stream.pause();
-          if (this.maxReceiveMessageSize !== -1 && messageBytes.length - 5 > this.maxReceiveMessageSize) {
-            this.sendStatus({
-              code: constants_1.Status.RESOURCE_EXHAUSTED,
-              details: `Received message larger than max (${messageBytes.length - 5} vs. ${this.maxReceiveMessageSize})`,
-              metadata: null
-            });
-            return;
-          }
           const queueEntry = {
             type: "COMPRESSED",
             compressedMessage: messageBytes,
@@ -54156,9 +55306,8 @@ var require_server_interceptors = __commonJS({
         if (this.checkCancelled()) {
           return;
         }
-        this.notifyOnCancel();
         trace("Request to method " + ((_a = this.handler) === null || _a === void 0 ? void 0 : _a.path) + " ended with status code: " + constants_1.Status[status.code] + " details: " + status.details);
-        if (this.stream.headersSent) {
+        if (this.metadataSent) {
           if (!this.wantTrailers) {
             this.wantTrailers = true;
             this.stream.once("wantTrailers", () => {
@@ -54170,8 +55319,11 @@ var require_server_interceptors = __commonJS({
               }
               const trailersToSend = Object.assign({ [GRPC_STATUS_HEADER]: status.code, [GRPC_MESSAGE_HEADER]: encodeURI(status.details) }, (_a2 = status.metadata) === null || _a2 === void 0 ? void 0 : _a2.toHttp2Headers());
               this.stream.sendTrailers(trailersToSend);
+              this.notifyOnCancel();
             });
             this.stream.end();
+          } else {
+            this.notifyOnCancel();
           }
         } else {
           if (this.callEventTracker && !this.streamEnded) {
@@ -54181,6 +55333,7 @@ var require_server_interceptors = __commonJS({
           }
           const trailersToSend = Object.assign(Object.assign({ [GRPC_STATUS_HEADER]: status.code, [GRPC_MESSAGE_HEADER]: encodeURI(status.details) }, defaultResponseHeaders), (_b = status.metadata) === null || _b === void 0 ? void 0 : _b.toHttp2Headers());
           this.stream.respond(trailersToSend, { endStream: true });
+          this.notifyOnCancel();
         }
       }
       startRead() {
@@ -54213,6 +55366,9 @@ var require_server_interceptors = __commonJS({
       getDeadline() {
         return this.deadline;
       }
+      getHost() {
+        return this.host;
+      }
     };
     exports2.BaseServerInterceptingCall = BaseServerInterceptingCall;
     function getServerInterceptingCall(interceptors, stream, headers, callEventTracker, handler, options) {
@@ -54291,8 +55447,10 @@ var require_server = __commonJS({
     var UNLIMITED_CONNECTION_AGE_MS = ~(1 << 31);
     var KEEPALIVE_MAX_TIME_MS = ~(1 << 31);
     var KEEPALIVE_TIMEOUT_MS = 2e4;
+    var MAX_CONNECTION_IDLE_MS = ~(1 << 31);
     var { HTTP2_HEADER_PATH } = http2.constants;
     var TRACER_NAME = "server";
+    var kMaxAge = Buffer.from("max_age");
     function noop() {
     }
     function deprecate(message) {
@@ -54335,31 +55493,36 @@ var require_server = __commonJS({
       let _start_decorators;
       return _a = class Server {
         constructor(options) {
-          var _b, _c, _d, _e, _f;
+          var _b, _c, _d, _e, _f, _g;
           this.boundPorts = (__runInitializers(this, _instanceExtraInitializers), /* @__PURE__ */ new Map());
           this.http2Servers = /* @__PURE__ */ new Map();
+          this.sessionIdleTimeouts = /* @__PURE__ */ new Map();
           this.handlers = /* @__PURE__ */ new Map();
           this.sessions = /* @__PURE__ */ new Map();
           this.started = false;
           this.shutdown = false;
           this.serverAddressString = "null";
           this.channelzEnabled = true;
-          this.channelzTrace = new channelz_1.ChannelzTrace();
-          this.callTracker = new channelz_1.ChannelzCallTracker();
-          this.listenerChildrenTracker = new channelz_1.ChannelzChildrenTracker();
-          this.sessionChildrenTracker = new channelz_1.ChannelzChildrenTracker();
           this.options = options !== null && options !== void 0 ? options : {};
           if (this.options["grpc.enable_channelz"] === 0) {
             this.channelzEnabled = false;
+            this.channelzTrace = new channelz_1.ChannelzTraceStub();
+            this.callTracker = new channelz_1.ChannelzCallTrackerStub();
+            this.listenerChildrenTracker = new channelz_1.ChannelzChildrenTrackerStub();
+            this.sessionChildrenTracker = new channelz_1.ChannelzChildrenTrackerStub();
+          } else {
+            this.channelzTrace = new channelz_1.ChannelzTrace();
+            this.callTracker = new channelz_1.ChannelzCallTracker();
+            this.listenerChildrenTracker = new channelz_1.ChannelzChildrenTracker();
+            this.sessionChildrenTracker = new channelz_1.ChannelzChildrenTracker();
           }
-          this.channelzRef = (0, channelz_1.registerChannelzServer)(() => this.getChannelzInfo(), this.channelzEnabled);
-          if (this.channelzEnabled) {
-            this.channelzTrace.addTrace("CT_INFO", "Server created");
-          }
+          this.channelzRef = (0, channelz_1.registerChannelzServer)("server", () => this.getChannelzInfo(), this.channelzEnabled);
+          this.channelzTrace.addTrace("CT_INFO", "Server created");
           this.maxConnectionAgeMs = (_b = this.options["grpc.max_connection_age_ms"]) !== null && _b !== void 0 ? _b : UNLIMITED_CONNECTION_AGE_MS;
           this.maxConnectionAgeGraceMs = (_c = this.options["grpc.max_connection_age_grace_ms"]) !== null && _c !== void 0 ? _c : UNLIMITED_CONNECTION_AGE_MS;
           this.keepaliveTimeMs = (_d = this.options["grpc.keepalive_time_ms"]) !== null && _d !== void 0 ? _d : KEEPALIVE_MAX_TIME_MS;
           this.keepaliveTimeoutMs = (_e = this.options["grpc.keepalive_timeout_ms"]) !== null && _e !== void 0 ? _e : KEEPALIVE_TIMEOUT_MS;
+          this.sessionIdleTimeout = (_f = this.options["grpc.max_connection_idle_ms"]) !== null && _f !== void 0 ? _f : MAX_CONNECTION_IDLE_MS;
           this.commonServerOptions = {
             maxSendHeaderBlockLength: Number.MAX_SAFE_INTEGER
           };
@@ -54373,7 +55536,7 @@ var require_server = __commonJS({
               maxConcurrentStreams: this.options["grpc.max_concurrent_streams"]
             };
           }
-          this.interceptors = (_f = this.options.interceptors) !== null && _f !== void 0 ? _f : [];
+          this.interceptors = (_g = this.options.interceptors) !== null && _g !== void 0 ? _g : [];
           this.trace("Server constructed");
         }
         getChannelzInfo() {
@@ -54384,52 +55547,53 @@ var require_server = __commonJS({
             sessionChildren: this.sessionChildrenTracker.getChildLists()
           };
         }
-        getChannelzSessionInfoGetter(session) {
-          return () => {
-            var _b, _c, _d;
-            const sessionInfo = this.sessions.get(session);
-            const sessionSocket = session.socket;
-            const remoteAddress = sessionSocket.remoteAddress ? (0, subchannel_address_1.stringToSubchannelAddress)(sessionSocket.remoteAddress, sessionSocket.remotePort) : null;
-            const localAddress = sessionSocket.localAddress ? (0, subchannel_address_1.stringToSubchannelAddress)(sessionSocket.localAddress, sessionSocket.localPort) : null;
-            let tlsInfo;
-            if (session.encrypted) {
-              const tlsSocket = sessionSocket;
-              const cipherInfo = tlsSocket.getCipher();
-              const certificate = tlsSocket.getCertificate();
-              const peerCertificate = tlsSocket.getPeerCertificate();
-              tlsInfo = {
-                cipherSuiteStandardName: (_b = cipherInfo.standardName) !== null && _b !== void 0 ? _b : null,
-                cipherSuiteOtherName: cipherInfo.standardName ? null : cipherInfo.name,
-                localCertificate: certificate && "raw" in certificate ? certificate.raw : null,
-                remoteCertificate: peerCertificate && "raw" in peerCertificate ? peerCertificate.raw : null
-              };
-            } else {
-              tlsInfo = null;
-            }
-            const socketInfo = {
-              remoteAddress,
-              localAddress,
-              security: tlsInfo,
-              remoteName: null,
-              streamsStarted: sessionInfo.streamTracker.callsStarted,
-              streamsSucceeded: sessionInfo.streamTracker.callsSucceeded,
-              streamsFailed: sessionInfo.streamTracker.callsFailed,
-              messagesSent: sessionInfo.messagesSent,
-              messagesReceived: sessionInfo.messagesReceived,
-              keepAlivesSent: 0,
-              lastLocalStreamCreatedTimestamp: null,
-              lastRemoteStreamCreatedTimestamp: sessionInfo.streamTracker.lastCallStartedTimestamp,
-              lastMessageSentTimestamp: sessionInfo.lastMessageSentTimestamp,
-              lastMessageReceivedTimestamp: sessionInfo.lastMessageReceivedTimestamp,
-              localFlowControlWindow: (_c = session.state.localWindowSize) !== null && _c !== void 0 ? _c : null,
-              remoteFlowControlWindow: (_d = session.state.remoteWindowSize) !== null && _d !== void 0 ? _d : null
+        getChannelzSessionInfo(session) {
+          var _b, _c, _d;
+          const sessionInfo = this.sessions.get(session);
+          const sessionSocket = session.socket;
+          const remoteAddress = sessionSocket.remoteAddress ? (0, subchannel_address_1.stringToSubchannelAddress)(sessionSocket.remoteAddress, sessionSocket.remotePort) : null;
+          const localAddress = sessionSocket.localAddress ? (0, subchannel_address_1.stringToSubchannelAddress)(sessionSocket.localAddress, sessionSocket.localPort) : null;
+          let tlsInfo;
+          if (session.encrypted) {
+            const tlsSocket = sessionSocket;
+            const cipherInfo = tlsSocket.getCipher();
+            const certificate = tlsSocket.getCertificate();
+            const peerCertificate = tlsSocket.getPeerCertificate();
+            tlsInfo = {
+              cipherSuiteStandardName: (_b = cipherInfo.standardName) !== null && _b !== void 0 ? _b : null,
+              cipherSuiteOtherName: cipherInfo.standardName ? null : cipherInfo.name,
+              localCertificate: certificate && "raw" in certificate ? certificate.raw : null,
+              remoteCertificate: peerCertificate && "raw" in peerCertificate ? peerCertificate.raw : null
             };
-            return socketInfo;
+          } else {
+            tlsInfo = null;
+          }
+          const socketInfo = {
+            remoteAddress,
+            localAddress,
+            security: tlsInfo,
+            remoteName: null,
+            streamsStarted: sessionInfo.streamTracker.callsStarted,
+            streamsSucceeded: sessionInfo.streamTracker.callsSucceeded,
+            streamsFailed: sessionInfo.streamTracker.callsFailed,
+            messagesSent: sessionInfo.messagesSent,
+            messagesReceived: sessionInfo.messagesReceived,
+            keepAlivesSent: sessionInfo.keepAlivesSent,
+            lastLocalStreamCreatedTimestamp: null,
+            lastRemoteStreamCreatedTimestamp: sessionInfo.streamTracker.lastCallStartedTimestamp,
+            lastMessageSentTimestamp: sessionInfo.lastMessageSentTimestamp,
+            lastMessageReceivedTimestamp: sessionInfo.lastMessageReceivedTimestamp,
+            localFlowControlWindow: (_c = session.state.localWindowSize) !== null && _c !== void 0 ? _c : null,
+            remoteFlowControlWindow: (_d = session.state.remoteWindowSize) !== null && _d !== void 0 ? _d : null
           };
+          return socketInfo;
         }
         trace(text) {
           logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, "(" + this.channelzRef.id + ") " + text);
         }
+        keepaliveTrace(text) {
+          logging.trace(constants_1.LogVerbosity.DEBUG, "keepalive", "(" + this.channelzRef.id + ") " + text);
+        }
         addProtoService() {
           throw new Error("Not implemented. Use addService() instead");
         }
@@ -54511,19 +55675,35 @@ var require_server = __commonJS({
         createHttp2Server(credentials) {
           let http2Server;
           if (credentials._isSecure()) {
-            const secureServerOptions = Object.assign(this.commonServerOptions, credentials._getSettings());
-            secureServerOptions.enableTrace = this.options["grpc-node.tls_enable_trace"] === 1;
+            const credentialsSettings = credentials._getSettings();
+            const secureServerOptions = Object.assign(Object.assign(Object.assign({}, this.commonServerOptions), credentialsSettings), { enableTrace: this.options["grpc-node.tls_enable_trace"] === 1 });
+            let areCredentialsValid = credentialsSettings !== null;
             http2Server = http2.createSecureServer(secureServerOptions);
+            http2Server.on("connection", (socket) => {
+              if (!areCredentialsValid) {
+                socket.destroy();
+              }
+            });
             http2Server.on("secureConnection", (socket) => {
               socket.on("error", (e) => {
                 this.trace("An incoming TLS connection closed with error: " + e.message);
               });
             });
+            const credsWatcher = (options) => {
+              if (options) {
+                http2Server.setSecureContext(options);
+              }
+              areCredentialsValid = options !== null;
+            };
+            credentials._addWatcher(credsWatcher);
+            http2Server.on("close", () => {
+              credentials._removeWatcher(credsWatcher);
+            });
           } else {
             http2Server = http2.createServer(this.commonServerOptions);
           }
           http2Server.setTimeout(0, noop);
-          this._setupHandlers(http2Server);
+          this._setupHandlers(http2Server, credentials._getInterceptors());
           return http2Server;
         }
         bindOneAddress(address, boundPortObject) {
@@ -54552,9 +55732,7 @@ var require_server = __commonJS({
                 };
               }
               const channelzRef = this.registerListenerToChannelz(boundSubchannelAddress);
-              if (this.channelzEnabled) {
-                this.listenerChildrenTracker.refChild(channelzRef);
-              }
+              this.listenerChildrenTracker.refChild(channelzRef);
               this.http2Servers.set(http2Server, {
                 channelzRef,
                 sessions: /* @__PURE__ */ new Set()
@@ -54601,12 +55779,7 @@ var require_server = __commonJS({
           }
         }
         async bindAddressList(addressList, boundPortObject) {
-          let bindResult;
-          try {
-            bindResult = await this.bindManyPorts(addressList, boundPortObject);
-          } catch (error) {
-            throw error;
-          }
+          const bindResult = await this.bindManyPorts(addressList, boundPortObject);
           if (bindResult.count > 0) {
             if (bindResult.count < addressList.length) {
               logging.log(constants_1.LogVerbosity.INFO, `WARNING Only ${bindResult.count} addresses added out of total ${addressList.length} resolved`);
@@ -54733,11 +55906,70 @@ var require_server = __commonJS({
             });
           }
         }
+        registerInjectorToChannelz() {
+          return (0, channelz_1.registerChannelzSocket)("injector", () => {
+            return {
+              localAddress: null,
+              remoteAddress: null,
+              security: null,
+              remoteName: null,
+              streamsStarted: 0,
+              streamsSucceeded: 0,
+              streamsFailed: 0,
+              messagesSent: 0,
+              messagesReceived: 0,
+              keepAlivesSent: 0,
+              lastLocalStreamCreatedTimestamp: null,
+              lastRemoteStreamCreatedTimestamp: null,
+              lastMessageSentTimestamp: null,
+              lastMessageReceivedTimestamp: null,
+              localFlowControlWindow: null,
+              remoteFlowControlWindow: null
+            };
+          }, this.channelzEnabled);
+        }
+        createConnectionInjector(credentials) {
+          if (credentials === null || !(credentials instanceof server_credentials_1.ServerCredentials)) {
+            throw new TypeError("creds must be a ServerCredentials object");
+          }
+          const server = this.createHttp2Server(credentials);
+          const channelzRef = this.registerInjectorToChannelz();
+          if (this.channelzEnabled) {
+            this.listenerChildrenTracker.refChild(channelzRef);
+          }
+          const sessionsSet = /* @__PURE__ */ new Set();
+          this.http2Servers.set(server, {
+            channelzRef,
+            sessions: sessionsSet
+          });
+          return {
+            injectConnection: (connection) => {
+              server.emit("connection", connection);
+            },
+            drain: (graceTimeMs) => {
+              var _b, _c;
+              for (const session of sessionsSet) {
+                this.closeSession(session);
+              }
+              (_c = (_b = setTimeout(() => {
+                for (const session of sessionsSet) {
+                  session.destroy(http2.constants.NGHTTP2_CANCEL);
+                }
+              }, graceTimeMs)).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+            },
+            destroy: () => {
+              this.closeServer(server);
+              for (const session of sessionsSet) {
+                this.closeSession(session);
+              }
+            }
+          };
+        }
         closeServer(server, callback) {
           this.trace("Closing server with address " + JSON.stringify(server.address()));
           const serverInfo = this.http2Servers.get(server);
           server.close(() => {
-            if (this.channelzEnabled && serverInfo) {
+            if (serverInfo) {
               this.listenerChildrenTracker.unrefChild(serverInfo.channelzRef);
               (0, channelz_1.unregisterChannelzRef)(serverInfo.channelzRef);
             }
@@ -54750,15 +55982,14 @@ var require_server = __commonJS({
           this.trace("Closing session initiated by " + ((_b = session.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress));
           const sessionInfo = this.sessions.get(session);
           const closeCallback = () => {
-            if (this.channelzEnabled && sessionInfo) {
+            if (sessionInfo) {
               this.sessionChildrenTracker.unrefChild(sessionInfo.ref);
               (0, channelz_1.unregisterChannelzRef)(sessionInfo.ref);
             }
-            this.sessions.delete(session);
             callback === null || callback === void 0 ? void 0 : callback();
           };
           if (session.closed) {
-            process.nextTick(closeCallback);
+            queueMicrotask(closeCallback);
           } else {
             session.close(closeCallback);
           }
@@ -54827,14 +56058,13 @@ var require_server = __commonJS({
           const allSessions = /* @__PURE__ */ new Set();
           for (const http2Server of boundPortObject.listeningServers) {
             const serverEntry = this.http2Servers.get(http2Server);
-            if (!serverEntry) {
-              continue;
-            }
-            for (const session of serverEntry.sessions) {
-              allSessions.add(session);
-              this.closeSession(session, () => {
-                allSessions.delete(session);
-              });
+            if (serverEntry) {
+              for (const session of serverEntry.sessions) {
+                allSessions.add(session);
+                this.closeSession(session, () => {
+                  allSessions.delete(session);
+                });
+              }
             }
           }
           (_c = (_b = setTimeout(() => {
@@ -54856,9 +56086,7 @@ var require_server = __commonJS({
             session.destroy(http2.constants.NGHTTP2_CANCEL);
           });
           this.sessions.clear();
-          if (this.channelzEnabled) {
-            (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
-          }
+          (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
           this.shutdown = true;
         }
         register(name2, handler, serialize, deserialize, type) {
@@ -54892,9 +56120,7 @@ var require_server = __commonJS({
         tryShutdown(callback) {
           var _b;
           const wrappedCallback = (error) => {
-            if (this.channelzEnabled) {
-              (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
-            }
+            (0, channelz_1.unregisterChannelzRef)(this.channelzRef);
             callback(error);
           };
           let pendingChecks = 0;
@@ -54905,23 +56131,23 @@ var require_server = __commonJS({
             }
           }
           this.shutdown = true;
-          for (const server of this.http2Servers.keys()) {
+          for (const [serverKey, server] of this.http2Servers.entries()) {
             pendingChecks++;
-            const serverString = this.http2Servers.get(server).channelzRef.name;
+            const serverString = server.channelzRef.name;
             this.trace("Waiting for server " + serverString + " to close");
-            this.closeServer(server, () => {
+            this.closeServer(serverKey, () => {
               this.trace("Server " + serverString + " finished closing");
               maybeCallback();
             });
-          }
-          for (const session of this.sessions.keys()) {
-            pendingChecks++;
-            const sessionString = (_b = session.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress;
-            this.trace("Waiting for session " + sessionString + " to close");
-            this.closeSession(session, () => {
-              this.trace("Session " + sessionString + " finished closing");
-              maybeCallback();
-            });
+            for (const session of server.sessions.keys()) {
+              pendingChecks++;
+              const sessionString = (_b = session.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress;
+              this.trace("Waiting for session " + sessionString + " to close");
+              this.closeSession(session, () => {
+                this.trace("Session " + sessionString + " finished closing");
+                maybeCallback();
+              });
+            }
           }
           if (pendingChecks === 0) {
             wrappedCallback();
@@ -54961,12 +56187,11 @@ var require_server = __commonJS({
           var _b, _c;
           const trailersToSend = Object.assign({ "grpc-status": (_b = err.code) !== null && _b !== void 0 ? _b : constants_1.Status.INTERNAL, "grpc-message": err.details, [http2.constants.HTTP2_HEADER_STATUS]: http2.constants.HTTP_STATUS_OK, [http2.constants.HTTP2_HEADER_CONTENT_TYPE]: "application/grpc+proto" }, (_c = err.metadata) === null || _c === void 0 ? void 0 : _c.toHttp2Headers());
           stream.respond(trailersToSend, { endStream: true });
-          if (this.channelzEnabled) {
-            this.callTracker.addCallFailed();
-            channelzSessionInfo === null || channelzSessionInfo === void 0 ? void 0 : channelzSessionInfo.streamTracker.addCallFailed();
-          }
+          this.callTracker.addCallFailed();
+          channelzSessionInfo === null || channelzSessionInfo === void 0 ? void 0 : channelzSessionInfo.streamTracker.addCallFailed();
         }
-        _channelzHandler(stream, headers) {
+        _channelzHandler(extraInterceptors, stream, headers) {
+          this.onStreamOpened(stream);
           const channelzSessionInfo = this.sessions.get(stream.session);
           this.callTracker.addCallStarted();
           channelzSessionInfo === null || channelzSessionInfo === void 0 ? void 0 : channelzSessionInfo.streamTracker.addCallStarted();
@@ -54981,7 +56206,7 @@ var require_server = __commonJS({
             this._respondWithError(getUnimplementedStatusResponse(path), stream, channelzSessionInfo);
             return;
           }
-          let callEventTracker = {
+          const callEventTracker = {
             addMessageSent: () => {
               if (channelzSessionInfo) {
                 channelzSessionInfo.messagesSent += 1;
@@ -55011,7 +56236,7 @@ var require_server = __commonJS({
               }
             }
           };
-          const call = (0, server_interceptors_1.getServerInterceptingCall)(this.interceptors, stream, headers, callEventTracker, handler, this.options);
+          const call = (0, server_interceptors_1.getServerInterceptingCall)([...extraInterceptors, ...this.interceptors], stream, headers, callEventTracker, handler, this.options);
           if (!this._runHandlerForCall(call, handler)) {
             this.callTracker.addCallFailed();
             channelzSessionInfo === null || channelzSessionInfo === void 0 ? void 0 : channelzSessionInfo.streamTracker.addCallFailed();
@@ -55021,7 +56246,8 @@ var require_server = __commonJS({
             });
           }
         }
-        _streamHandler(stream, headers) {
+        _streamHandler(extraInterceptors, stream, headers) {
+          this.onStreamOpened(stream);
           if (this._verifyContentType(stream, headers) !== true) {
             return;
           }
@@ -55031,7 +56257,7 @@ var require_server = __commonJS({
             this._respondWithError(getUnimplementedStatusResponse(path), stream, null);
             return;
           }
-          const call = (0, server_interceptors_1.getServerInterceptingCall)(this.interceptors, stream, headers, null, handler, this.options);
+          const call = (0, server_interceptors_1.getServerInterceptingCall)([...extraInterceptors, ...this.interceptors], stream, headers, null, handler, this.options);
           if (!this._runHandlerForCall(call, handler)) {
             call.sendStatus({
               code: constants_1.Status.INTERNAL,
@@ -55054,7 +56280,7 @@ var require_server = __commonJS({
           }
           return true;
         }
-        _setupHandlers(http2Server) {
+        _setupHandlers(http2Server, extraInterceptors) {
           if (http2Server === null) {
             return;
           }
@@ -55069,90 +56295,310 @@ var require_server = __commonJS({
           }
           this.serverAddressString = serverAddressString;
           const handler = this.channelzEnabled ? this._channelzHandler : this._streamHandler;
-          http2Server.on("stream", handler.bind(this));
-          http2Server.on("session", (session) => {
-            var _b, _c, _d, _e, _f, _g;
-            const channelzRef = (0, channelz_1.registerChannelzSocket)((_b = session.socket.remoteAddress) !== null && _b !== void 0 ? _b : "unknown", this.getChannelzSessionInfoGetter(session), this.channelzEnabled);
+          const sessionHandler = this.channelzEnabled ? this._channelzSessionHandler(http2Server) : this._sessionHandler(http2Server);
+          http2Server.on("stream", handler.bind(this, extraInterceptors));
+          http2Server.on("session", sessionHandler);
+        }
+        _sessionHandler(http2Server) {
+          return (session) => {
+            var _b, _c;
+            (_b = this.http2Servers.get(http2Server)) === null || _b === void 0 ? void 0 : _b.sessions.add(session);
+            let connectionAgeTimer = null;
+            let connectionAgeGraceTimer = null;
+            let keepaliveTimer = null;
+            let sessionClosedByServer = false;
+            const idleTimeoutObj = this.enableIdleTimeout(session);
+            if (this.maxConnectionAgeMs !== UNLIMITED_CONNECTION_AGE_MS) {
+              const jitterMagnitude = this.maxConnectionAgeMs / 10;
+              const jitter = Math.random() * jitterMagnitude * 2 - jitterMagnitude;
+              connectionAgeTimer = setTimeout(() => {
+                var _b2, _c2;
+                sessionClosedByServer = true;
+                this.trace("Connection dropped by max connection age: " + ((_b2 = session.socket) === null || _b2 === void 0 ? void 0 : _b2.remoteAddress));
+                try {
+                  session.goaway(http2.constants.NGHTTP2_NO_ERROR, ~(1 << 31), kMaxAge);
+                } catch (e) {
+                  session.destroy();
+                  return;
+                }
+                session.close();
+                if (this.maxConnectionAgeGraceMs !== UNLIMITED_CONNECTION_AGE_MS) {
+                  connectionAgeGraceTimer = setTimeout(() => {
+                    session.destroy();
+                  }, this.maxConnectionAgeGraceMs);
+                  (_c2 = connectionAgeGraceTimer.unref) === null || _c2 === void 0 ? void 0 : _c2.call(connectionAgeGraceTimer);
+                }
+              }, this.maxConnectionAgeMs + jitter);
+              (_c = connectionAgeTimer.unref) === null || _c === void 0 ? void 0 : _c.call(connectionAgeTimer);
+            }
+            const clearKeepaliveTimeout = () => {
+              if (keepaliveTimer) {
+                clearTimeout(keepaliveTimer);
+                keepaliveTimer = null;
+              }
+            };
+            const canSendPing = () => {
+              return !session.destroyed && this.keepaliveTimeMs < KEEPALIVE_MAX_TIME_MS && this.keepaliveTimeMs > 0;
+            };
+            let sendPing;
+            const maybeStartKeepalivePingTimer = () => {
+              var _b2;
+              if (!canSendPing()) {
+                return;
+              }
+              this.keepaliveTrace("Starting keepalive timer for " + this.keepaliveTimeMs + "ms");
+              keepaliveTimer = setTimeout(() => {
+                clearKeepaliveTimeout();
+                sendPing();
+              }, this.keepaliveTimeMs);
+              (_b2 = keepaliveTimer.unref) === null || _b2 === void 0 ? void 0 : _b2.call(keepaliveTimer);
+            };
+            sendPing = () => {
+              var _b2;
+              if (!canSendPing()) {
+                return;
+              }
+              this.keepaliveTrace("Sending ping with timeout " + this.keepaliveTimeoutMs + "ms");
+              let pingSendError = "";
+              try {
+                const pingSentSuccessfully = session.ping((err, duration, payload) => {
+                  clearKeepaliveTimeout();
+                  if (err) {
+                    this.keepaliveTrace("Ping failed with error: " + err.message);
+                    sessionClosedByServer = true;
+                    session.close();
+                  } else {
+                    this.keepaliveTrace("Received ping response");
+                    maybeStartKeepalivePingTimer();
+                  }
+                });
+                if (!pingSentSuccessfully) {
+                  pingSendError = "Ping returned false";
+                }
+              } catch (e) {
+                pingSendError = (e instanceof Error ? e.message : "") || "Unknown error";
+              }
+              if (pingSendError) {
+                this.keepaliveTrace("Ping send failed: " + pingSendError);
+                this.trace("Connection dropped due to ping send error: " + pingSendError);
+                sessionClosedByServer = true;
+                session.close();
+                return;
+              }
+              keepaliveTimer = setTimeout(() => {
+                clearKeepaliveTimeout();
+                this.keepaliveTrace("Ping timeout passed without response");
+                this.trace("Connection dropped by keepalive timeout");
+                sessionClosedByServer = true;
+                session.close();
+              }, this.keepaliveTimeoutMs);
+              (_b2 = keepaliveTimer.unref) === null || _b2 === void 0 ? void 0 : _b2.call(keepaliveTimer);
+            };
+            maybeStartKeepalivePingTimer();
+            session.on("close", () => {
+              var _b2, _c2;
+              if (!sessionClosedByServer) {
+                this.trace(`Connection dropped by client ${(_b2 = session.socket) === null || _b2 === void 0 ? void 0 : _b2.remoteAddress}`);
+              }
+              if (connectionAgeTimer) {
+                clearTimeout(connectionAgeTimer);
+              }
+              if (connectionAgeGraceTimer) {
+                clearTimeout(connectionAgeGraceTimer);
+              }
+              clearKeepaliveTimeout();
+              if (idleTimeoutObj !== null) {
+                clearTimeout(idleTimeoutObj.timeout);
+                this.sessionIdleTimeouts.delete(session);
+              }
+              (_c2 = this.http2Servers.get(http2Server)) === null || _c2 === void 0 ? void 0 : _c2.sessions.delete(session);
+            });
+          };
+        }
+        _channelzSessionHandler(http2Server) {
+          return (session) => {
+            var _b, _c, _d, _e;
+            const channelzRef = (0, channelz_1.registerChannelzSocket)((_c = (_b = session.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress) !== null && _c !== void 0 ? _c : "unknown", this.getChannelzSessionInfo.bind(this, session), this.channelzEnabled);
             const channelzSessionInfo = {
               ref: channelzRef,
               streamTracker: new channelz_1.ChannelzCallTracker(),
               messagesSent: 0,
               messagesReceived: 0,
+              keepAlivesSent: 0,
               lastMessageSentTimestamp: null,
               lastMessageReceivedTimestamp: null
             };
-            (_c = this.http2Servers.get(http2Server)) === null || _c === void 0 ? void 0 : _c.sessions.add(session);
+            (_d = this.http2Servers.get(http2Server)) === null || _d === void 0 ? void 0 : _d.sessions.add(session);
             this.sessions.set(session, channelzSessionInfo);
-            const clientAddress = session.socket.remoteAddress;
-            if (this.channelzEnabled) {
-              this.channelzTrace.addTrace("CT_INFO", "Connection established by client " + clientAddress);
-              this.sessionChildrenTracker.refChild(channelzRef);
-            }
+            const clientAddress = `${session.socket.remoteAddress}:${session.socket.remotePort}`;
+            this.channelzTrace.addTrace("CT_INFO", "Connection established by client " + clientAddress);
+            this.trace("Connection established by client " + clientAddress);
+            this.sessionChildrenTracker.refChild(channelzRef);
             let connectionAgeTimer = null;
             let connectionAgeGraceTimer = null;
+            let keepaliveTimeout = null;
             let sessionClosedByServer = false;
+            const idleTimeoutObj = this.enableIdleTimeout(session);
             if (this.maxConnectionAgeMs !== UNLIMITED_CONNECTION_AGE_MS) {
               const jitterMagnitude = this.maxConnectionAgeMs / 10;
               const jitter = Math.random() * jitterMagnitude * 2 - jitterMagnitude;
-              connectionAgeTimer = (_e = (_d = setTimeout(() => {
-                var _b2, _c2;
+              connectionAgeTimer = setTimeout(() => {
+                var _b2;
                 sessionClosedByServer = true;
-                if (this.channelzEnabled) {
-                  this.channelzTrace.addTrace("CT_INFO", "Connection dropped by max connection age from " + clientAddress);
-                }
+                this.channelzTrace.addTrace("CT_INFO", "Connection dropped by max connection age from " + clientAddress);
                 try {
-                  session.goaway(http2.constants.NGHTTP2_NO_ERROR, ~(1 << 31), Buffer.from("max_age"));
+                  session.goaway(http2.constants.NGHTTP2_NO_ERROR, ~(1 << 31), kMaxAge);
                 } catch (e) {
                   session.destroy();
                   return;
                 }
                 session.close();
                 if (this.maxConnectionAgeGraceMs !== UNLIMITED_CONNECTION_AGE_MS) {
-                  connectionAgeGraceTimer = (_c2 = (_b2 = setTimeout(() => {
+                  connectionAgeGraceTimer = setTimeout(() => {
                     session.destroy();
-                  }, this.maxConnectionAgeGraceMs)).unref) === null || _c2 === void 0 ? void 0 : _c2.call(_b2);
+                  }, this.maxConnectionAgeGraceMs);
+                  (_b2 = connectionAgeGraceTimer.unref) === null || _b2 === void 0 ? void 0 : _b2.call(connectionAgeGraceTimer);
                 }
-              }, this.maxConnectionAgeMs + jitter)).unref) === null || _e === void 0 ? void 0 : _e.call(_d);
+              }, this.maxConnectionAgeMs + jitter);
+              (_e = connectionAgeTimer.unref) === null || _e === void 0 ? void 0 : _e.call(connectionAgeTimer);
             }
-            const keeapliveTimeTimer = (_g = (_f = setInterval(() => {
-              var _b2, _c2;
-              const timeoutTImer = (_c2 = (_b2 = setTimeout(() => {
-                sessionClosedByServer = true;
-                if (this.channelzEnabled) {
-                  this.channelzTrace.addTrace("CT_INFO", "Connection dropped by keepalive timeout from " + clientAddress);
-                }
-                session.close();
-              }, this.keepaliveTimeoutMs)).unref) === null || _c2 === void 0 ? void 0 : _c2.call(_b2);
+            const clearKeepaliveTimeout = () => {
+              if (keepaliveTimeout) {
+                clearTimeout(keepaliveTimeout);
+                keepaliveTimeout = null;
+              }
+            };
+            const canSendPing = () => {
+              return !session.destroyed && this.keepaliveTimeMs < KEEPALIVE_MAX_TIME_MS && this.keepaliveTimeMs > 0;
+            };
+            let sendPing;
+            const maybeStartKeepalivePingTimer = () => {
+              var _b2;
+              if (!canSendPing()) {
+                return;
+              }
+              this.keepaliveTrace("Starting keepalive timer for " + this.keepaliveTimeMs + "ms");
+              keepaliveTimeout = setTimeout(() => {
+                clearKeepaliveTimeout();
+                sendPing();
+              }, this.keepaliveTimeMs);
+              (_b2 = keepaliveTimeout.unref) === null || _b2 === void 0 ? void 0 : _b2.call(keepaliveTimeout);
+            };
+            sendPing = () => {
+              var _b2;
+              if (!canSendPing()) {
+                return;
+              }
+              this.keepaliveTrace("Sending ping with timeout " + this.keepaliveTimeoutMs + "ms");
+              let pingSendError = "";
               try {
-                session.ping((err, duration, payload) => {
-                  clearTimeout(timeoutTImer);
+                const pingSentSuccessfully = session.ping((err, duration, payload) => {
+                  clearKeepaliveTimeout();
+                  if (err) {
+                    this.keepaliveTrace("Ping failed with error: " + err.message);
+                    this.channelzTrace.addTrace("CT_INFO", "Connection dropped due to error of a ping frame " + err.message + " return in " + duration);
+                    sessionClosedByServer = true;
+                    session.close();
+                  } else {
+                    this.keepaliveTrace("Received ping response");
+                    maybeStartKeepalivePingTimer();
+                  }
                 });
+                if (!pingSentSuccessfully) {
+                  pingSendError = "Ping returned false";
+                }
               } catch (e) {
-                session.destroy();
+                pingSendError = (e instanceof Error ? e.message : "") || "Unknown error";
+              }
+              if (pingSendError) {
+                this.keepaliveTrace("Ping send failed: " + pingSendError);
+                this.channelzTrace.addTrace("CT_INFO", "Connection dropped due to ping send error: " + pingSendError);
+                sessionClosedByServer = true;
+                session.close();
+                return;
               }
-            }, this.keepaliveTimeMs)).unref) === null || _g === void 0 ? void 0 : _g.call(_f);
+              channelzSessionInfo.keepAlivesSent += 1;
+              keepaliveTimeout = setTimeout(() => {
+                clearKeepaliveTimeout();
+                this.keepaliveTrace("Ping timeout passed without response");
+                this.channelzTrace.addTrace("CT_INFO", "Connection dropped by keepalive timeout from " + clientAddress);
+                sessionClosedByServer = true;
+                session.close();
+              }, this.keepaliveTimeoutMs);
+              (_b2 = keepaliveTimeout.unref) === null || _b2 === void 0 ? void 0 : _b2.call(keepaliveTimeout);
+            };
+            maybeStartKeepalivePingTimer();
             session.on("close", () => {
               var _b2;
-              if (this.channelzEnabled) {
-                if (!sessionClosedByServer) {
-                  this.channelzTrace.addTrace("CT_INFO", "Connection dropped by client " + clientAddress);
-                }
-                this.sessionChildrenTracker.unrefChild(channelzRef);
-                (0, channelz_1.unregisterChannelzRef)(channelzRef);
+              if (!sessionClosedByServer) {
+                this.channelzTrace.addTrace("CT_INFO", "Connection dropped by client " + clientAddress);
               }
+              this.sessionChildrenTracker.unrefChild(channelzRef);
+              (0, channelz_1.unregisterChannelzRef)(channelzRef);
               if (connectionAgeTimer) {
                 clearTimeout(connectionAgeTimer);
               }
               if (connectionAgeGraceTimer) {
                 clearTimeout(connectionAgeGraceTimer);
               }
-              if (keeapliveTimeTimer) {
-                clearTimeout(keeapliveTimeTimer);
+              clearKeepaliveTimeout();
+              if (idleTimeoutObj !== null) {
+                clearTimeout(idleTimeoutObj.timeout);
+                this.sessionIdleTimeouts.delete(session);
               }
               (_b2 = this.http2Servers.get(http2Server)) === null || _b2 === void 0 ? void 0 : _b2.sessions.delete(session);
               this.sessions.delete(session);
             });
-          });
+          };
+        }
+        enableIdleTimeout(session) {
+          var _b, _c;
+          if (this.sessionIdleTimeout >= MAX_CONNECTION_IDLE_MS) {
+            return null;
+          }
+          const idleTimeoutObj = {
+            activeStreams: 0,
+            lastIdle: Date.now(),
+            onClose: this.onStreamClose.bind(this, session),
+            timeout: setTimeout(this.onIdleTimeout, this.sessionIdleTimeout, this, session)
+          };
+          (_c = (_b = idleTimeoutObj.timeout).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+          this.sessionIdleTimeouts.set(session, idleTimeoutObj);
+          const { socket } = session;
+          this.trace("Enable idle timeout for " + socket.remoteAddress + ":" + socket.remotePort);
+          return idleTimeoutObj;
+        }
+        onIdleTimeout(ctx, session) {
+          const { socket } = session;
+          const sessionInfo = ctx.sessionIdleTimeouts.get(session);
+          if (sessionInfo !== void 0 && sessionInfo.activeStreams === 0) {
+            if (Date.now() - sessionInfo.lastIdle >= ctx.sessionIdleTimeout) {
+              ctx.trace("Session idle timeout triggered for " + (socket === null || socket === void 0 ? void 0 : socket.remoteAddress) + ":" + (socket === null || socket === void 0 ? void 0 : socket.remotePort) + " last idle at " + sessionInfo.lastIdle);
+              ctx.closeSession(session);
+            } else {
+              sessionInfo.timeout.refresh();
+            }
+          }
+        }
+        onStreamOpened(stream) {
+          const session = stream.session;
+          const idleTimeoutObj = this.sessionIdleTimeouts.get(session);
+          if (idleTimeoutObj) {
+            idleTimeoutObj.activeStreams += 1;
+            stream.once("close", idleTimeoutObj.onClose);
+          }
+        }
+        onStreamClose(session) {
+          var _b, _c;
+          const idleTimeoutObj = this.sessionIdleTimeouts.get(session);
+          if (idleTimeoutObj) {
+            idleTimeoutObj.activeStreams -= 1;
+            if (idleTimeoutObj.activeStreams === 0) {
+              idleTimeoutObj.lastIdle = Date.now();
+              idleTimeoutObj.timeout.refresh();
+              this.trace("Session onStreamClose" + ((_b = session.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress) + ":" + ((_c = session.socket) === null || _c === void 0 ? void 0 : _c.remotePort) + " at " + idleTimeoutObj.lastIdle);
+            }
+          }
         }
       }, (() => {
         const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
@@ -55437,9 +56883,10 @@ var require_load_balancer_pick_first = __commonJS({
     var load_balancer_1 = require_load_balancer();
     var connectivity_state_1 = require_connectivity_state();
     var picker_1 = require_picker();
+    var subchannel_address_1 = require_subchannel_address();
     var logging = require_logging();
     var constants_1 = require_constants8();
-    var subchannel_address_1 = require_subchannel_address();
+    var subchannel_address_2 = require_subchannel_address();
     var net_1 = __require("net");
     var TRACER_NAME = "pick_first";
     function trace(text) {
@@ -55502,9 +56949,9 @@ var require_load_balancer_pick_first = __commonJS({
       const result = [];
       const ipv6Addresses = [];
       const ipv4Addresses = [];
-      const ipv6First = (0, subchannel_address_1.isTcpSubchannelAddress)(addressList[0]) && (0, net_1.isIPv6)(addressList[0].host);
+      const ipv6First = (0, subchannel_address_2.isTcpSubchannelAddress)(addressList[0]) && (0, net_1.isIPv6)(addressList[0].host);
       for (const address of addressList) {
-        if ((0, subchannel_address_1.isTcpSubchannelAddress)(address) && (0, net_1.isIPv6)(address.host)) {
+        if ((0, subchannel_address_2.isTcpSubchannelAddress)(address) && (0, net_1.isIPv6)(address.host)) {
           ipv6Addresses.push(address);
         } else {
           ipv4Addresses.push(address);
@@ -55541,9 +56988,7 @@ var require_load_balancer_pick_first = __commonJS({
           this.onSubchannelStateUpdate(subchannel, previousState, newState, errorMessage);
         };
         this.pickedSubchannelHealthListener = () => this.calculateAndReportNewState();
-        this.triedAllSubchannels = false;
         this.stickyTransientFailureMode = false;
-        this.requestedResolutionSinceLastUpdate = false;
         this.lastError = null;
         this.latestAddressList = null;
         this.connectionDelayTimeout = setTimeout(() => {
@@ -55554,6 +56999,9 @@ var require_load_balancer_pick_first = __commonJS({
       allChildrenHaveReportedTF() {
         return this.children.every((child) => child.hasReportedTransientFailure);
       }
+      resetChildrenReportedTF() {
+        this.children.every((child) => child.hasReportedTransientFailure = false);
+      }
       calculateAndReportNewState() {
         if (this.currentPick) {
           if (this.reportHealthStatus && !this.currentPick.isHealthy()) {
@@ -55567,23 +57015,23 @@ var require_load_balancer_pick_first = __commonJS({
           this.updateState(connectivity_state_1.ConnectivityState.IDLE, new picker_1.QueuePicker(this));
         } else {
           if (this.stickyTransientFailureMode) {
-            this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({ details: `No connection established. Last error: ${this.lastError}` }));
+            this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
+              details: `No connection established. Last error: ${this.lastError}`
+            }));
           } else {
             this.updateState(connectivity_state_1.ConnectivityState.CONNECTING, new picker_1.QueuePicker(this));
           }
         }
       }
       requestReresolution() {
-        this.requestedResolutionSinceLastUpdate = true;
         this.channelControlHelper.requestReresolution();
       }
       maybeEnterStickyTransientFailureMode() {
         if (!this.allChildrenHaveReportedTF()) {
           return;
         }
-        if (!this.requestedResolutionSinceLastUpdate) {
-          this.requestReresolution();
-        }
+        this.requestReresolution();
+        this.resetChildrenReportedTF();
         if (this.stickyTransientFailureMode) {
           return;
         }
@@ -55595,14 +57043,11 @@ var require_load_balancer_pick_first = __commonJS({
       }
       removeCurrentPick() {
         if (this.currentPick !== null) {
-          const currentPick = this.currentPick;
+          this.currentPick.removeConnectivityStateListener(this.subchannelStateListener);
+          this.channelControlHelper.removeChannelzChild(this.currentPick.getChannelzRef());
+          this.currentPick.removeHealthStateWatcher(this.pickedSubchannelHealthListener);
+          this.currentPick.unref();
           this.currentPick = null;
-          currentPick.unref();
-          currentPick.removeConnectivityStateListener(this.subchannelStateListener);
-          this.channelControlHelper.removeChannelzChild(currentPick.getChannelzRef());
-          if (this.reportHealthStatus) {
-            currentPick.removeHealthStateWatcher(this.pickedSubchannelHealthListener);
-          }
         }
       }
       onSubchannelStateUpdate(subchannel, previousState, newState, errorMessage) {
@@ -55611,7 +57056,6 @@ var require_load_balancer_pick_first = __commonJS({
           if (newState !== connectivity_state_1.ConnectivityState.READY) {
             this.removeCurrentPick();
             this.calculateAndReportNewState();
-            this.requestReresolution();
           }
           return;
         }
@@ -55637,9 +57081,6 @@ var require_load_balancer_pick_first = __commonJS({
       }
       startNextSubchannelConnecting(startIndex) {
         clearTimeout(this.connectionDelayTimeout);
-        if (this.triedAllSubchannels) {
-          return;
-        }
         for (const [index, child] of this.children.entries()) {
           if (index >= startIndex) {
             const subchannelState = child.subchannel.getConnectivityState();
@@ -55649,7 +57090,6 @@ var require_load_balancer_pick_first = __commonJS({
             }
           }
         }
-        this.triedAllSubchannels = true;
         this.maybeEnterStickyTransientFailureMode();
       }
       /**
@@ -55667,24 +57107,28 @@ var require_load_balancer_pick_first = __commonJS({
             (_a2 = this.children[subchannelIndex]) === null || _a2 === void 0 ? void 0 : _a2.subchannel.startConnecting();
           });
         }
-        this.connectionDelayTimeout = (_b = (_a = setTimeout(() => {
+        this.connectionDelayTimeout = setTimeout(() => {
           this.startNextSubchannelConnecting(subchannelIndex + 1);
-        }, CONNECTION_DELAY_INTERVAL_MS)).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }, CONNECTION_DELAY_INTERVAL_MS);
+        (_b = (_a = this.connectionDelayTimeout).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
       }
+      /**
+       * Declare that the specified subchannel should be used to make requests.
+       * This functions the same independent of whether subchannel is a member of
+       * this.children and whether it is equal to this.currentPick.
+       * Prerequisite: subchannel.getConnectivityState() === READY.
+       * @param subchannel
+       */
       pickSubchannel(subchannel) {
-        if (this.currentPick && subchannel.realSubchannelEquals(this.currentPick)) {
-          return;
-        }
         trace("Pick subchannel with address " + subchannel.getAddress());
         this.stickyTransientFailureMode = false;
-        this.removeCurrentPick();
-        this.currentPick = subchannel;
         subchannel.ref();
-        if (this.reportHealthStatus) {
-          subchannel.addHealthStateWatcher(this.pickedSubchannelHealthListener);
-        }
         this.channelControlHelper.addChannelzChild(subchannel.getChannelzRef());
+        this.removeCurrentPick();
         this.resetSubchannelList();
+        subchannel.addConnectivityStateListener(this.subchannelStateListener);
+        subchannel.addHealthStateWatcher(this.pickedSubchannelHealthListener);
+        this.currentPick = subchannel;
         clearTimeout(this.connectionDelayTimeout);
         this.calculateAndReportNewState();
       }
@@ -55695,22 +57139,25 @@ var require_load_balancer_pick_first = __commonJS({
       }
       resetSubchannelList() {
         for (const child of this.children) {
-          if (!(this.currentPick && child.subchannel.realSubchannelEquals(this.currentPick))) {
-            child.subchannel.removeConnectivityStateListener(this.subchannelStateListener);
-          }
+          child.subchannel.removeConnectivityStateListener(this.subchannelStateListener);
           child.subchannel.unref();
           this.channelControlHelper.removeChannelzChild(child.subchannel.getChannelzRef());
         }
         this.currentSubchannelIndex = 0;
         this.children = [];
-        this.triedAllSubchannels = false;
-        this.requestedResolutionSinceLastUpdate = false;
       }
       connectToAddressList(addressList) {
+        trace("connectToAddressList([" + addressList.map((address) => (0, subchannel_address_1.subchannelAddressToString)(address)) + "])");
         const newChildrenList = addressList.map((address) => ({
           subchannel: this.channelControlHelper.createSubchannel(address, {}),
           hasReportedTransientFailure: false
         }));
+        for (const { subchannel } of newChildrenList) {
+          if (subchannel.getConnectivityState() === connectivity_state_1.ConnectivityState.READY) {
+            this.pickSubchannel(subchannel);
+            return;
+          }
+        }
         for (const { subchannel } of newChildrenList) {
           subchannel.ref();
           this.channelControlHelper.addChannelzChild(subchannel.getChannelzRef());
@@ -55719,10 +57166,6 @@ var require_load_balancer_pick_first = __commonJS({
         this.children = newChildrenList;
         for (const { subchannel } of this.children) {
           subchannel.addConnectivityStateListener(this.subchannelStateListener);
-          if (subchannel.getConnectivityState() === connectivity_state_1.ConnectivityState.READY) {
-            this.pickSubchannel(subchannel);
-            return;
-          }
         }
         for (const child of this.children) {
           if (child.subchannel.getConnectivityState() === connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE) {
@@ -55740,6 +57183,7 @@ var require_load_balancer_pick_first = __commonJS({
           endpointList = shuffled(endpointList);
         }
         const rawAddressList = [].concat(...endpointList.map((endpoint) => endpoint.addresses));
+        trace("updateAddressList([" + rawAddressList.map((address) => (0, subchannel_address_1.subchannelAddressToString)(address)) + "])");
         if (rawAddressList.length === 0) {
           throw new Error("No addresses in endpoint list passed to pick_first");
         }
@@ -55823,7 +57267,7 @@ var require_experimental = __commonJS({
   "node_modules/@grpc/grpc-js/build/src/experimental.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.BaseSubchannelWrapper = exports2.registerAdminService = exports2.FilterStackFactory = exports2.BaseFilter = exports2.PickResultType = exports2.QueuePicker = exports2.UnavailablePicker = exports2.ChildLoadBalancerHandler = exports2.EndpointMap = exports2.endpointHasAddress = exports2.endpointToString = exports2.subchannelAddressToString = exports2.LeafLoadBalancer = exports2.isLoadBalancerNameRegistered = exports2.parseLoadBalancingConfig = exports2.selectLbConfigFromList = exports2.registerLoadBalancerType = exports2.createChildChannelControlHelper = exports2.BackoffTimeout = exports2.durationToMs = exports2.uriToString = exports2.createResolver = exports2.registerResolver = exports2.log = exports2.trace = void 0;
+    exports2.createServerCredentialsWithInterceptors = exports2.BaseSubchannelWrapper = exports2.registerAdminService = exports2.FilterStackFactory = exports2.BaseFilter = exports2.PickResultType = exports2.QueuePicker = exports2.UnavailablePicker = exports2.ChildLoadBalancerHandler = exports2.EndpointMap = exports2.endpointHasAddress = exports2.endpointToString = exports2.subchannelAddressToString = exports2.LeafLoadBalancer = exports2.isLoadBalancerNameRegistered = exports2.parseLoadBalancingConfig = exports2.selectLbConfigFromList = exports2.registerLoadBalancerType = exports2.createChildChannelControlHelper = exports2.BackoffTimeout = exports2.durationToMs = exports2.splitHostPort = exports2.uriToString = exports2.createResolver = exports2.registerResolver = exports2.log = exports2.trace = void 0;
     var logging_1 = require_logging();
     Object.defineProperty(exports2, "trace", { enumerable: true, get: function() {
       return logging_1.trace;
@@ -55842,6 +57286,9 @@ var require_experimental = __commonJS({
     Object.defineProperty(exports2, "uriToString", { enumerable: true, get: function() {
       return uri_parser_1.uriToString;
     } });
+    Object.defineProperty(exports2, "splitHostPort", { enumerable: true, get: function() {
+      return uri_parser_1.splitHostPort;
+    } });
     var duration_1 = require_duration();
     Object.defineProperty(exports2, "durationToMs", { enumerable: true, get: function() {
       return duration_1.durationToMs;
@@ -55913,6 +57360,10 @@ var require_experimental = __commonJS({
     Object.defineProperty(exports2, "BaseSubchannelWrapper", { enumerable: true, get: function() {
       return subchannel_interface_1.BaseSubchannelWrapper;
     } });
+    var server_credentials_1 = require_server_credentials();
+    Object.defineProperty(exports2, "createServerCredentialsWithInterceptors", { enumerable: true, get: function() {
+      return server_credentials_1.createServerCredentialsWithInterceptors;
+    } });
   }
 });
 
@@ -55943,6 +57394,7 @@ var require_resolver_uds = __commonJS({
         }
       }
       destroy() {
+        this.hasReturnedResult = false;
       }
       static getDefaultAuthority(target) {
         return "localhost";
@@ -56109,6 +57561,9 @@ var require_load_balancer_round_robin = __commonJS({
         this.lastError = null;
         this.childChannelControlHelper = (0, load_balancer_1.createChildChannelControlHelper)(channelControlHelper, {
           updateState: (connectivityState, picker) => {
+            if (this.currentState === connectivity_state_1.ConnectivityState.READY && connectivityState !== connectivity_state_1.ConnectivityState.READY) {
+              this.channelControlHelper.requestReresolution();
+            }
             this.calculateAndUpdateState();
           }
         });
@@ -56137,7 +57592,9 @@ var require_load_balancer_round_robin = __commonJS({
         } else if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.CONNECTING) > 0) {
           this.updateState(connectivity_state_1.ConnectivityState.CONNECTING, new picker_1.QueuePicker(this));
         } else if (this.countChildrenWithState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE) > 0) {
-          this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({ details: `No connection established. Last error: ${this.lastError}` }));
+          this.updateState(connectivity_state_1.ConnectivityState.TRANSIENT_FAILURE, new picker_1.UnavailablePicker({
+            details: `No connection established. Last error: ${this.lastError}`
+          }));
         } else {
           this.updateState(connectivity_state_1.ConnectivityState.IDLE, new picker_1.QueuePicker(this));
         }
@@ -65377,7 +66834,7 @@ var require_sampling7 = __commonJS({
 });
 
 // node_modules/@opentelemetry/exporter-zipkin/node_modules/@opentelemetry/core/build/src/utils/environment.js
-var require_environment13 = __commonJS({
+var require_environment14 = __commonJS({
   "node_modules/@opentelemetry/exporter-zipkin/node_modules/@opentelemetry/core/build/src/utils/environment.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -65582,12 +67039,12 @@ var require_environment13 = __commonJS({
 });
 
 // node_modules/@opentelemetry/exporter-zipkin/node_modules/@opentelemetry/core/build/src/platform/node/environment.js
-var require_environment14 = __commonJS({
+var require_environment15 = __commonJS({
   "node_modules/@opentelemetry/exporter-zipkin/node_modules/@opentelemetry/core/build/src/platform/node/environment.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getEnvWithoutDefaults = exports2.getEnv = void 0;
-    var environment_1 = require_environment13();
+    var environment_1 = require_environment14();
     function getEnv() {
       const processEnv = (0, environment_1.parseEnvironment)(process.env);
       return Object.assign({}, environment_1.DEFAULT_ENVIRONMENT, processEnv);
@@ -65756,7 +67213,7 @@ var require_node21 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getEnv = exports2.getEnvWithoutDefaults = void 0;
-    var environment_1 = require_environment14();
+    var environment_1 = require_environment15();
     Object.defineProperty(exports2, "getEnvWithoutDefaults", { enumerable: true, get: function() {
       return environment_1.getEnvWithoutDefaults;
     } });
@@ -66682,7 +68139,7 @@ var require_src34 = __commonJS({
     __exportStar(require_TraceIdRatioBasedSampler9(), exports2);
     __exportStar(require_suppress_tracing7(), exports2);
     __exportStar(require_TraceState7(), exports2);
-    __exportStar(require_environment13(), exports2);
+    __exportStar(require_environment14(), exports2);
     __exportStar(require_merge7(), exports2);
     __exportStar(require_sampling7(), exports2);
     __exportStar(require_timeout7(), exports2);
@@ -67409,7 +68866,7 @@ var import_semantic_conventions = __toESM(require_src(), 1);
 import { getLogger } from "./request-context.cjs";
 var {
   default: { version, name }
-} = await import("../../esm-chunks/package-NNKZAPVX.js");
+} = await import("../../esm-chunks/package-EEQP43EX.js");
 var sdk = new import_sdk_node.NodeSDK({
   resource: new import_resources.Resource({
     [import_semantic_conventions.SEMRESATTRS_SERVICE_NAME]: name,