agent-skill-manager 1.22.0 → 2.0.0

package/node_modules/@grpc/grpc-js/src/internal-channel.ts

@@ -1,878 +0,0 @@
-/*
- * Copyright 2019 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-import { ChannelCredentials } from './channel-credentials';
-import { ChannelOptions } from './channel-options';
-import { ResolvingLoadBalancer } from './resolving-load-balancer';
-import { SubchannelPool, getSubchannelPool } from './subchannel-pool';
-import { ChannelControlHelper } from './load-balancer';
-import { UnavailablePicker, Picker, QueuePicker, PickArgs, PickResult, PickResultType } from './picker';
-import { Metadata } from './metadata';
-import { Status, LogVerbosity, Propagate } from './constants';
-import { FilterStackFactory } from './filter-stack';
-import { CompressionFilterFactory } from './compression-filter';
-import {
-  CallConfig,
-  ConfigSelector,
-  getDefaultAuthority,
-  mapUriDefaultScheme,
-} from './resolver';
-import { trace, isTracerEnabled } from './logging';
-import { SubchannelAddress } from './subchannel-address';
-import { mapProxyName } from './http_proxy';
-import { GrpcUri, parseUri, uriToString } from './uri-parser';
-import { ServerSurfaceCall } from './server-call';
-
-import { ConnectivityState } from './connectivity-state';
-import {
-  ChannelInfo,
-  ChannelRef,
-  ChannelzCallTracker,
-  ChannelzChildrenTracker,
-  ChannelzTrace,
-  registerChannelzChannel,
-  SubchannelRef,
-  unregisterChannelzRef,
-} from './channelz';
-import { LoadBalancingCall } from './load-balancing-call';
-import { CallCredentials } from './call-credentials';
-import { Call, CallStreamOptions, StatusObject } from './call-interface';
-import { Deadline, deadlineToString } from './deadline';
-import { ResolvingCall } from './resolving-call';
-import { getNextCallNumber } from './call-number';
-import { restrictControlPlaneStatusCode } from './control-plane-status';
-import {
-  MessageBufferTracker,
-  RetryingCall,
-  RetryThrottler,
-} from './retrying-call';
-import {
-  BaseSubchannelWrapper,
-  ConnectivityStateListener,
-  SubchannelInterface,
-} from './subchannel-interface';
-
-/**
- * See https://nodejs.org/api/timers.html#timers_setinterval_callback_delay_args
- */
-const MAX_TIMEOUT_TIME = 2147483647;
-
-const MIN_IDLE_TIMEOUT_MS = 1000;
-
-// 30 minutes
-const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
-
-interface ConnectivityStateWatcher {
-  currentState: ConnectivityState;
-  timer: NodeJS.Timeout | null;
-  callback: (error?: Error) => void;
-}
-
-interface NoneConfigResult {
-  type: 'NONE';
-}
-
-interface SuccessConfigResult {
-  type: 'SUCCESS';
-  config: CallConfig;
-}
-
-interface ErrorConfigResult {
-  type: 'ERROR';
-  error: StatusObject;
-}
-
-type GetConfigResult =
-  | NoneConfigResult
-  | SuccessConfigResult
-  | ErrorConfigResult;
-
-const RETRY_THROTTLER_MAP: Map<string, RetryThrottler> = new Map();
-
-const DEFAULT_RETRY_BUFFER_SIZE_BYTES = 1 << 24; // 16 MB
-const DEFAULT_PER_RPC_RETRY_BUFFER_SIZE_BYTES = 1 << 20; // 1 MB
-
-class ChannelSubchannelWrapper
-  extends BaseSubchannelWrapper
-  implements SubchannelInterface
-{
-  private refCount = 0;
-  private subchannelStateListener: ConnectivityStateListener;
-  constructor(
-    childSubchannel: SubchannelInterface,
-    private channel: InternalChannel
-  ) {
-    super(childSubchannel);
-    this.subchannelStateListener = (
-      subchannel,
-      previousState,
-      newState,
-      keepaliveTime
-    ) => {
-      channel.throttleKeepalive(keepaliveTime);
-    };
-  }
-
-  ref(): void {
-    if (this.refCount === 0) {
-      this.child.addConnectivityStateListener(this.subchannelStateListener);
-      this.channel.addWrappedSubchannel(this);
-    }
-    this.child.ref();
-    this.refCount += 1;
-  }
-
-  unref(): void {
-    this.child.unref();
-    this.refCount -= 1;
-    if (this.refCount <= 0) {
-      this.child.removeConnectivityStateListener(this.subchannelStateListener);
-      this.channel.removeWrappedSubchannel(this);
-    }
-  }
-}
-
-class ShutdownPicker implements Picker {
-  pick(pickArgs: PickArgs): PickResult {
-    return {
-      pickResultType: PickResultType.DROP,
-      status: {
-        code: Status.UNAVAILABLE,
-        details: 'Channel closed before call started',
-        metadata: new Metadata()
-      },
-      subchannel: null,
-      onCallStarted: null,
-      onCallEnded: null
-    }
-  }
-}
-
-export const SUBCHANNEL_ARGS_EXCLUDE_KEY_PREFIX = 'grpc.internal.no_subchannel';
-class ChannelzInfoTracker {
-  readonly trace = new ChannelzTrace();
-  readonly callTracker = new ChannelzCallTracker();
-  readonly childrenTracker = new ChannelzChildrenTracker();
-  state: ConnectivityState = ConnectivityState.IDLE;
-  constructor(private target: string) {}
-
-  getChannelzInfoCallback(): () => ChannelInfo {
-    return () => {
-      return {
-        target: this.target,
-        state: this.state,
-        trace: this.trace,
-        callTracker: this.callTracker,
-        children: this.childrenTracker.getChildLists()
-      };
-    };
-  }
-}
-
-export class InternalChannel {
-  private readonly resolvingLoadBalancer: ResolvingLoadBalancer;
-  private readonly subchannelPool: SubchannelPool;
-  private connectivityState: ConnectivityState = ConnectivityState.IDLE;
-  private currentPicker: Picker = new UnavailablePicker();
-  /**
-   * Calls queued up to get a call config. Should only be populated before the
-   * first time the resolver returns a result, which includes the ConfigSelector.
-   */
-  private configSelectionQueue: ResolvingCall[] = [];
-  private pickQueue: LoadBalancingCall[] = [];
-  private connectivityStateWatchers: ConnectivityStateWatcher[] = [];
-  private readonly defaultAuthority: string;
-  private readonly filterStackFactory: FilterStackFactory;
-  private readonly target: GrpcUri;
-  /**
-   * This timer does not do anything on its own. Its purpose is to hold the
-   * event loop open while there are any pending calls for the channel that
-   * have not yet been assigned to specific subchannels. In other words,
-   * the invariant is that callRefTimer is reffed if and only if pickQueue
-   * is non-empty. In addition, the timer is null while the state is IDLE or
-   * SHUTDOWN and there are no pending calls.
-   */
-  private callRefTimer: NodeJS.Timeout | null = null;
-  private configSelector: ConfigSelector | null = null;
-  /**
-   * This is the error from the name resolver if it failed most recently. It
-   * is only used to end calls that start while there is no config selector
-   * and the name resolver is in backoff, so it should be nulled if
-   * configSelector becomes set or the channel state becomes anything other
-   * than TRANSIENT_FAILURE.
-   */
-  private currentResolutionError: StatusObject | null = null;
-  private readonly retryBufferTracker: MessageBufferTracker;
-  private keepaliveTime: number;
-  private readonly wrappedSubchannels: Set<ChannelSubchannelWrapper> =
-    new Set();
-
-  private callCount = 0;
-  private idleTimer: NodeJS.Timeout | null = null;
-  private readonly idleTimeoutMs: number;
-  private lastActivityTimestamp: Date;
-
-  // Channelz info
-  private readonly channelzEnabled: boolean = true;
-  private readonly channelzRef: ChannelRef;
-  private readonly channelzInfoTracker: ChannelzInfoTracker;
-
-  /**
-   * Randomly generated ID to be passed to the config selector, for use by
-   * ring_hash in xDS. An integer distributed approximately uniformly between
-   * 0 and MAX_SAFE_INTEGER.
-   */
-  private readonly randomChannelId = Math.floor(
-    Math.random() * Number.MAX_SAFE_INTEGER
-  );
-
-  constructor(
-    target: string,
-    private readonly credentials: ChannelCredentials,
-    private readonly options: ChannelOptions
-  ) {
-    if (typeof target !== 'string') {
-      throw new TypeError('Channel target must be a string');
-    }
-    if (!(credentials instanceof ChannelCredentials)) {
-      throw new TypeError(
-        'Channel credentials must be a ChannelCredentials object'
-      );
-    }
-    if (options) {
-      if (typeof options !== 'object') {
-        throw new TypeError('Channel options must be an object');
-      }
-    }
-    this.channelzInfoTracker = new ChannelzInfoTracker(target);
-    const originalTargetUri = parseUri(target);
-    if (originalTargetUri === null) {
-      throw new Error(`Could not parse target name "${target}"`);
-    }
-    /* This ensures that the target has a scheme that is registered with the
-     * resolver */
-    const defaultSchemeMapResult = mapUriDefaultScheme(originalTargetUri);
-    if (defaultSchemeMapResult === null) {
-      throw new Error(
-        `Could not find a default scheme for target name "${target}"`
-      );
-    }
-
-    if (this.options['grpc.enable_channelz'] === 0) {
-      this.channelzEnabled = false;
-    }
-
-    this.channelzRef = registerChannelzChannel(
-      target,
-      this.channelzInfoTracker.getChannelzInfoCallback(),
-      this.channelzEnabled
-    );
-    if (this.channelzEnabled) {
-      this.channelzInfoTracker.trace.addTrace('CT_INFO', 'Channel created');
-    }
-
-    if (this.options['grpc.default_authority']) {
-      this.defaultAuthority = this.options['grpc.default_authority'] as string;
-    } else {
-      this.defaultAuthority = getDefaultAuthority(defaultSchemeMapResult);
-    }
-    const proxyMapResult = mapProxyName(defaultSchemeMapResult, options);
-    this.target = proxyMapResult.target;
-    this.options = Object.assign({}, this.options, proxyMapResult.extraOptions);
-
-    /* The global boolean parameter to getSubchannelPool has the inverse meaning to what
-     * the grpc.use_local_subchannel_pool channel option means. */
-    this.subchannelPool = getSubchannelPool(
-      (this.options['grpc.use_local_subchannel_pool'] ?? 0) === 0
-    );
-    this.retryBufferTracker = new MessageBufferTracker(
-      this.options['grpc.retry_buffer_size'] ?? DEFAULT_RETRY_BUFFER_SIZE_BYTES,
-      this.options['grpc.per_rpc_retry_buffer_size'] ??
-        DEFAULT_PER_RPC_RETRY_BUFFER_SIZE_BYTES
-    );
-    this.keepaliveTime = this.options['grpc.keepalive_time_ms'] ?? -1;
-    this.idleTimeoutMs = Math.max(
-      this.options['grpc.client_idle_timeout_ms'] ?? DEFAULT_IDLE_TIMEOUT_MS,
-      MIN_IDLE_TIMEOUT_MS
-    );
-    const channelControlHelper: ChannelControlHelper = {
-      createSubchannel: (
-        subchannelAddress: SubchannelAddress,
-        subchannelArgs: ChannelOptions
-      ) => {
-        const finalSubchannelArgs: ChannelOptions = {};
-        for (const [key, value] of Object.entries(subchannelArgs)) {
-          if (!key.startsWith(SUBCHANNEL_ARGS_EXCLUDE_KEY_PREFIX)) {
-            finalSubchannelArgs[key] = value;
-          }
-        }
-        const subchannel = this.subchannelPool.getOrCreateSubchannel(
-          this.target,
-          subchannelAddress,
-          finalSubchannelArgs,
-          this.credentials
-        );
-        subchannel.throttleKeepalive(this.keepaliveTime);
-        if (this.channelzEnabled) {
-          this.channelzInfoTracker.trace.addTrace(
-            'CT_INFO',
-            'Created subchannel or used existing subchannel',
-            subchannel.getChannelzRef()
-          );
-        }
-        const wrappedSubchannel = new ChannelSubchannelWrapper(
-          subchannel,
-          this
-        );
-        return wrappedSubchannel;
-      },
-      updateState: (connectivityState: ConnectivityState, picker: Picker) => {
-        this.currentPicker = picker;
-        const queueCopy = this.pickQueue.slice();
-        this.pickQueue = [];
-        if (queueCopy.length > 0) {
-          this.callRefTimerUnref();
-        }
-        for (const call of queueCopy) {
-          call.doPick();
-        }
-        this.updateState(connectivityState);
-      },
-      requestReresolution: () => {
-        // This should never be called.
-        throw new Error(
-          'Resolving load balancer should never call requestReresolution'
-        );
-      },
-      addChannelzChild: (child: ChannelRef | SubchannelRef) => {
-        if (this.channelzEnabled) {
-          this.channelzInfoTracker.childrenTracker.refChild(child);
-        }
-      },
-      removeChannelzChild: (child: ChannelRef | SubchannelRef) => {
-        if (this.channelzEnabled) {
-          this.channelzInfoTracker.childrenTracker.unrefChild(child);
-        }
-      },
-    };
-    this.resolvingLoadBalancer = new ResolvingLoadBalancer(
-      this.target,
-      channelControlHelper,
-      this.options,
-      (serviceConfig, configSelector) => {
-        if (serviceConfig.retryThrottling) {
-          RETRY_THROTTLER_MAP.set(
-            this.getTarget(),
-            new RetryThrottler(
-              serviceConfig.retryThrottling.maxTokens,
-              serviceConfig.retryThrottling.tokenRatio,
-              RETRY_THROTTLER_MAP.get(this.getTarget())
-            )
-          );
-        } else {
-          RETRY_THROTTLER_MAP.delete(this.getTarget());
-        }
-        if (this.channelzEnabled) {
-          this.channelzInfoTracker.trace.addTrace(
-            'CT_INFO',
-            'Address resolution succeeded'
-          );
-        }
-        this.configSelector?.unref();
-        this.configSelector = configSelector;
-        this.currentResolutionError = null;
-        /* We process the queue asynchronously to ensure that the corresponding
-         * load balancer update has completed. */
-        process.nextTick(() => {
-          const localQueue = this.configSelectionQueue;
-          this.configSelectionQueue = [];
-          if (localQueue.length > 0) {
-            this.callRefTimerUnref();
-          }
-          for (const call of localQueue) {
-            call.getConfig();
-          }
-        });
-      },
-      status => {
-        if (this.channelzEnabled) {
-          this.channelzInfoTracker.trace.addTrace(
-            'CT_WARNING',
-            'Address resolution failed with code ' +
-              status.code +
-              ' and details "' +
-              status.details +
-              '"'
-          );
-        }
-        if (this.configSelectionQueue.length > 0) {
-          this.trace(
-            'Name resolution failed with calls queued for config selection'
-          );
-        }
-        if (this.configSelector === null) {
-          this.currentResolutionError = {
-            ...restrictControlPlaneStatusCode(status.code, status.details),
-            metadata: status.metadata,
-          };
-        }
-        const localQueue = this.configSelectionQueue;
-        this.configSelectionQueue = [];
-        if (localQueue.length > 0) {
-          this.callRefTimerUnref();
-        }
-        for (const call of localQueue) {
-          call.reportResolverError(status);
-        }
-      }
-    );
-    this.filterStackFactory = new FilterStackFactory([
-      new CompressionFilterFactory(this, this.options),
-    ]);
-    this.trace(
-      'Channel constructed with options ' +
-        JSON.stringify(options, undefined, 2)
-    );
-    const error = new Error();
-    if (isTracerEnabled('channel_stacktrace')){
-      trace(
-        LogVerbosity.DEBUG,
-        'channel_stacktrace',
-        '(' +
-          this.channelzRef.id +
-          ') ' +
-          'Channel constructed \n' +
-          error.stack?.substring(error.stack.indexOf('\n') + 1)
-      );
-    }
-    this.lastActivityTimestamp = new Date();
-  }
-
-  private trace(text: string, verbosityOverride?: LogVerbosity) {
-    trace(
-      verbosityOverride ?? LogVerbosity.DEBUG,
-      'channel',
-      '(' + this.channelzRef.id + ') ' + uriToString(this.target) + ' ' + text
-    );
-  }
-
-  private callRefTimerRef() {
-    if (!this.callRefTimer) {
-      this.callRefTimer = setInterval(() => {}, MAX_TIMEOUT_TIME)
-    }
-    // If the hasRef function does not exist, always run the code
-    if (!this.callRefTimer.hasRef?.()) {
-      this.trace(
-        'callRefTimer.ref | configSelectionQueue.length=' +
-          this.configSelectionQueue.length +
-          ' pickQueue.length=' +
-          this.pickQueue.length
-      );
-      this.callRefTimer.ref?.();
-    }
-  }
-
-  private callRefTimerUnref() {
-    // If the timer or the hasRef function does not exist, always run the code
-    if (!this.callRefTimer?.hasRef || this.callRefTimer.hasRef()) {
-      this.trace(
-        'callRefTimer.unref | configSelectionQueue.length=' +
-          this.configSelectionQueue.length +
-          ' pickQueue.length=' +
-          this.pickQueue.length
-      );
-      this.callRefTimer?.unref?.();
-    }
-  }
-
-  private removeConnectivityStateWatcher(
-    watcherObject: ConnectivityStateWatcher
-  ) {
-    const watcherIndex = this.connectivityStateWatchers.findIndex(
-      value => value === watcherObject
-    );
-    if (watcherIndex >= 0) {
-      this.connectivityStateWatchers.splice(watcherIndex, 1);
-    }
-  }
-
-  private updateState(newState: ConnectivityState): void {
-    trace(
-      LogVerbosity.DEBUG,
-      'connectivity_state',
-      '(' +
-        this.channelzRef.id +
-        ') ' +
-        uriToString(this.target) +
-        ' ' +
-        ConnectivityState[this.connectivityState] +
-        ' -> ' +
-        ConnectivityState[newState]
-    );
-    if (this.channelzEnabled) {
-      this.channelzInfoTracker.trace.addTrace(
-        'CT_INFO',
-        'Connectivity state change to ' + ConnectivityState[newState]
-      );
-    }
-    this.connectivityState = newState;
-    this.channelzInfoTracker.state = newState;
-    const watchersCopy = this.connectivityStateWatchers.slice();
-    for (const watcherObject of watchersCopy) {
-      if (newState !== watcherObject.currentState) {
-        if (watcherObject.timer) {
-          clearTimeout(watcherObject.timer);
-        }
-        this.removeConnectivityStateWatcher(watcherObject);
-        watcherObject.callback();
-      }
-    }
-    if (newState !== ConnectivityState.TRANSIENT_FAILURE) {
-      this.currentResolutionError = null;
-    }
-  }
-
-  throttleKeepalive(newKeepaliveTime: number) {
-    if (newKeepaliveTime > this.keepaliveTime) {
-      this.keepaliveTime = newKeepaliveTime;
-      for (const wrappedSubchannel of this.wrappedSubchannels) {
-        wrappedSubchannel.throttleKeepalive(newKeepaliveTime);
-      }
-    }
-  }
-
-  addWrappedSubchannel(wrappedSubchannel: ChannelSubchannelWrapper) {
-    this.wrappedSubchannels.add(wrappedSubchannel);
-  }
-
-  removeWrappedSubchannel(wrappedSubchannel: ChannelSubchannelWrapper) {
-    this.wrappedSubchannels.delete(wrappedSubchannel);
-  }
-
-  doPick(metadata: Metadata, extraPickInfo: { [key: string]: string }) {
-    return this.currentPicker.pick({
-      metadata: metadata,
-      extraPickInfo: extraPickInfo,
-    });
-  }
-
-  queueCallForPick(call: LoadBalancingCall) {
-    this.pickQueue.push(call);
-    this.callRefTimerRef();
-  }
-
-  getConfig(method: string, metadata: Metadata): GetConfigResult {
-    if (this.connectivityState !== ConnectivityState.SHUTDOWN) {
-      this.resolvingLoadBalancer.exitIdle();
-    }
-    if (this.configSelector) {
-      return {
-        type: 'SUCCESS',
-        config: this.configSelector.invoke(method, metadata, this.randomChannelId),
-      };
-    } else {
-      if (this.currentResolutionError) {
-        return {
-          type: 'ERROR',
-          error: this.currentResolutionError,
-        };
-      } else {
-        return {
-          type: 'NONE',
-        };
-      }
-    }
-  }
-
-  queueCallForConfig(call: ResolvingCall) {
-    this.configSelectionQueue.push(call);
-    this.callRefTimerRef();
-  }
-
-  private enterIdle() {
-    this.resolvingLoadBalancer.destroy();
-    this.updateState(ConnectivityState.IDLE);
-    this.currentPicker = new QueuePicker(this.resolvingLoadBalancer);
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
-    }
-    if (this.callRefTimer) {
-      clearInterval(this.callRefTimer);
-      this.callRefTimer = null;
-    }
-  }
-
-  private startIdleTimeout(timeoutMs: number) {
-    this.idleTimer = setTimeout(() => {
-      if (this.callCount > 0) {
-        /* If there is currently a call, the channel will not go idle for a
-         * period of at least idleTimeoutMs, so check again after that time.
-         */
-        this.startIdleTimeout(this.idleTimeoutMs);
-        return;
-      }
-      const now = new Date();
-      const timeSinceLastActivity =
-        now.valueOf() - this.lastActivityTimestamp.valueOf();
-      if (timeSinceLastActivity >= this.idleTimeoutMs) {
-        this.trace(
-          'Idle timer triggered after ' +
-            this.idleTimeoutMs +
-            'ms of inactivity'
-        );
-        this.enterIdle();
-      } else {
-        /* Whenever the timer fires with the latest activity being too recent,
-         * set the timer again for the time when the time since the last
-         * activity is equal to the timeout. This should result in the timer
-         * firing no more than once every idleTimeoutMs/2 on average. */
-        this.startIdleTimeout(this.idleTimeoutMs - timeSinceLastActivity);
-      }
-    }, timeoutMs);
-    this.idleTimer.unref?.();
-  }
-
-  private maybeStartIdleTimer() {
-    if (
-      this.connectivityState !== ConnectivityState.SHUTDOWN &&
-      !this.idleTimer
-    ) {
-      this.startIdleTimeout(this.idleTimeoutMs);
-    }
-  }
-
-  private onCallStart() {
-    if (this.channelzEnabled) {
-      this.channelzInfoTracker.callTracker.addCallStarted();
-    }
-    this.callCount += 1;
-  }
-
-  private onCallEnd(status: StatusObject) {
-    if (this.channelzEnabled) {
-      if (status.code === Status.OK) {
-        this.channelzInfoTracker.callTracker.addCallSucceeded();
-      } else {
-        this.channelzInfoTracker.callTracker.addCallFailed();
-      }
-    }
-    this.callCount -= 1;
-    this.lastActivityTimestamp = new Date();
-    this.maybeStartIdleTimer();
-  }
-
-  createLoadBalancingCall(
-    callConfig: CallConfig,
-    method: string,
-    host: string,
-    credentials: CallCredentials,
-    deadline: Deadline
-  ): LoadBalancingCall {
-    const callNumber = getNextCallNumber();
-    this.trace(
-      'createLoadBalancingCall [' + callNumber + '] method="' + method + '"'
-    );
-    return new LoadBalancingCall(
-      this,
-      callConfig,
-      method,
-      host,
-      credentials,
-      deadline,
-      callNumber
-    );
-  }
-
-  createRetryingCall(
-    callConfig: CallConfig,
-    method: string,
-    host: string,
-    credentials: CallCredentials,
-    deadline: Deadline
-  ): RetryingCall {
-    const callNumber = getNextCallNumber();
-    this.trace(
-      'createRetryingCall [' + callNumber + '] method="' + method + '"'
-    );
-    return new RetryingCall(
-      this,
-      callConfig,
-      method,
-      host,
-      credentials,
-      deadline,
-      callNumber,
-      this.retryBufferTracker,
-      RETRY_THROTTLER_MAP.get(this.getTarget())
-    );
-  }
-
-  createResolvingCall(
-    method: string,
-    deadline: Deadline,
-    host: string | null | undefined,
-    parentCall: ServerSurfaceCall | null,
-    propagateFlags: number | null | undefined
-  ): ResolvingCall {
-    const callNumber = getNextCallNumber();
-    this.trace(
-      'createResolvingCall [' +
-        callNumber +
-        '] method="' +
-        method +
-        '", deadline=' +
-        deadlineToString(deadline)
-    );
-    const finalOptions: CallStreamOptions = {
-      deadline: deadline,
-      flags: propagateFlags ?? Propagate.DEFAULTS,
-      host: host ?? this.defaultAuthority,
-      parentCall: parentCall,
-    };
-
-    const call = new ResolvingCall(
-      this,
-      method,
-      finalOptions,
-      this.filterStackFactory.clone(),
-      callNumber
-    );
-
-    this.onCallStart();
-    call.addStatusWatcher(status => {
-      this.onCallEnd(status);
-    });
-    return call;
-  }
-
-  close() {
-    this.resolvingLoadBalancer.destroy();
-    this.updateState(ConnectivityState.SHUTDOWN);
-    this.currentPicker = new ShutdownPicker();
-    for (const call of this.configSelectionQueue) {
-      call.cancelWithStatus(Status.UNAVAILABLE, 'Channel closed before call started');
-    }
-    this.configSelectionQueue = [];
-    for (const call of this.pickQueue) {
-      call.cancelWithStatus(Status.UNAVAILABLE, 'Channel closed before call started');
-    }
-    this.pickQueue = [];
-    if (this.callRefTimer) {
-      clearInterval(this.callRefTimer);
-    }
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-    }
-    if (this.channelzEnabled) {
-      unregisterChannelzRef(this.channelzRef);
-    }
-
-    this.subchannelPool.unrefUnusedSubchannels();
-    this.configSelector?.unref();
-    this.configSelector = null;
-  }
-
-  getTarget() {
-    return uriToString(this.target);
-  }
-
-  getConnectivityState(tryToConnect: boolean) {
-    const connectivityState = this.connectivityState;
-    if (tryToConnect) {
-      this.resolvingLoadBalancer.exitIdle();
-      this.lastActivityTimestamp = new Date();
-      this.maybeStartIdleTimer();
-    }
-    return connectivityState;
-  }
-
-  watchConnectivityState(
-    currentState: ConnectivityState,
-    deadline: Date | number,
-    callback: (error?: Error) => void
-  ): void {
-    if (this.connectivityState === ConnectivityState.SHUTDOWN) {
-      throw new Error('Channel has been shut down');
-    }
-    let timer = null;
-    if (deadline !== Infinity) {
-      const deadlineDate: Date =
-        deadline instanceof Date ? deadline : new Date(deadline);
-      const now = new Date();
-      if (deadline === -Infinity || deadlineDate <= now) {
-        process.nextTick(
-          callback,
-          new Error('Deadline passed without connectivity state change')
-        );
-        return;
-      }
-      timer = setTimeout(() => {
-        this.removeConnectivityStateWatcher(watcherObject);
-        callback(
-          new Error('Deadline passed without connectivity state change')
-        );
-      }, deadlineDate.getTime() - now.getTime());
-    }
-    const watcherObject = {
-      currentState,
-      callback,
-      timer,
-    };
-    this.connectivityStateWatchers.push(watcherObject);
-  }
-
-  /**
-   * Get the channelz reference object for this channel. The returned value is
-   * garbage if channelz is disabled for this channel.
-   * @returns
-   */
-  getChannelzRef() {
-    return this.channelzRef;
-  }
-
-  createCall(
-    method: string,
-    deadline: Deadline,
-    host: string | null | undefined,
-    parentCall: ServerSurfaceCall | null,
-    propagateFlags: number | null | undefined
-  ): Call {
-    if (typeof method !== 'string') {
-      throw new TypeError('Channel#createCall: method must be a string');
-    }
-    if (!(typeof deadline === 'number' || deadline instanceof Date)) {
-      throw new TypeError(
-        'Channel#createCall: deadline must be a number or Date'
-      );
-    }
-    if (this.connectivityState === ConnectivityState.SHUTDOWN) {
-      throw new Error('Channel has been shut down');
-    }
-    return this.createResolvingCall(
-      method,
-      deadline,
-      host,
-      parentCall,
-      propagateFlags
-    );
-  }
-
-  getOptions() {
-    return this.options;
-  }
-}