},
      filterState:{
        activeUser: undefined,
        match: function(uname){
          return this.activeUser===uname || !this.activeUser;
        }
      },
      /**
         The timer object is used to control connection throttling
         when connection errors arrise. It starts off with a polling
         delay of $initialDelay ms. If there's a connection error,
         that gets bumped by some value for each subsequent error, up
         to some max value.

         The timeing of resetting the delay when service returns is,
         because of the long-poll connection and our lack of low-level
         insight into the connection at this level, a bit wonky.
      */
      timer:{
        id: undefined,
        $initialDelay: 1000 /* initial polling interval (ms) */,
        currentDelay: 1000 /* current polling interval */,
        maxDelay: 60000 /* max interval when backing off for
                              connection errors */,
        minDelay: 7000 /* minimum delay time */,
        idReconnect: undefined /*timer id for reconnection determination*/,
        incrDelay: function(){
          if( this.maxDelay > this.currentDelay ){
            this.currentDelay =
              (this.currentDelay < this.minDelay)
              ? this.minDelay
              : (this.currentDelay * 3);
          }
          return this.currentDelay;
        },
        resetDelay: function(){
          return this.currentDelay = this.$initialDelay;
        },
        isDelayed: function(){
          return this.currentDelay > this.$initialDelay;
        }
      },
      /**
         Gets (no args) or sets (1 arg) the current input text field
         value, taking into account single- vs multi-line input. The
         getter returns a trim()'d string and the setter returns this
         object. As a special case, if arguments[0] is a boolean
         value, it behaves like a getter and, if arguments[0]===true
         it clears the input field before returning.

        return this;
      },

      /**
         If animations are enabled, passes its arguments
         to D.addClassBriefly(), else this is a no-op.
         If cb is a function, it is called after the
         CSS class is removed. Returns this object; 
         CSS class is removed. Returns this object;
      */
      animate: function f(e,a,cb){
        if(!f.$disabled){
          D.addClassBriefly(e, a, 0, cb);
        }
        return this;
      }

       Accepts any argument types valid for fossil.toast.error().
    */
    cs.reportError = function(/*msg args*/){
      const args = argsToArray(arguments);
      console.error("chat error:",args);
      F.toast.error.apply(F.toast, args);
    };

    let InternalMsgId = 0;
    /**
       Reports an error in the form of a new message in the chat
       feed. All arguments are appended to the message's content area
       using fossil.dom.append(), so may be of any type supported by
       that function.
    */
    cs.reportErrorAsMessage = function f(/*msg args*/){
      if(undefined === f.$msgid) f.$msgid=0;
      const args = argsToArray(arguments).map(function(v){
        return (v instanceof Error) ? v.message : v;
      });
      if(Chat.verboseErrors){
      console.error("chat error:",args);
        console.error("chat error:",args);
      }
      const d = new Date().toISOString(),
            mw = new this.MessageWidget({
              isError: true,
              xfrom: null,
              msgid: "error-"+(++f.$msgid),
              xfrom: undefined,
              msgid: "error-"+(++InternalMsgId),
              mtime: d,
              lmtime: d,
              xmsg: args
            });
      this.injectMessageElem(mw.e.body);
      mw.scrollIntoView();
      return mw;
    };

    /**
       For use by the connection poller to send a "connection
       restored" message.
    */
    cs.reportReconnection = function f(/*msg args*/){
      const args = argsToArray(arguments).map(function(v){
        return (v instanceof Error) ? v.message : v;
      });
      const d = new Date().toISOString(),
            mw = new this.MessageWidget({
              isError: false,
              xfrom: undefined,
              msgid: "reconnect-"+(++InternalMsgId),
              mtime: d,
              lmtime: d,
              xmsg: args
            });
      this.injectMessageElem(mw.e.body);
      mw.scrollIntoView();
      return mw;
    };

    cs.getMessageElemById = function(id){
      return qs('[data-msgid="'+id+'"]');
    };

    /** Finds the last .message-widget element and returns it or

      if(state.msg) Chat.inputValue(state.msg);
      if(state.blob) BlobXferState.updateDropZoneContent(state.blob);
      const theMsg = findMessageWidgetParent(w);
      if(theMsg) Chat.deleteMessageElem(theMsg);
    }));
    Chat.reportErrorAsMessage(w);
  };

  /* Assume the connection has been established, reset
     the Chat.timer.idReconnect, and alert the user
     that the outage appears to be over. */
  const reportConnectionReestablished = function(){
    if( Chat.timer.idReconnect ){
      clearTimeout(Chat.timer.idReconnect);
      Chat.timer.idReconnect = 0;
    }
    if( Chat.timer.isDelayed() ){
      Chat.timer.resetDelay();
      Chat.reportReconnection(
        "Connection restored after outage."
      );
      setTimeout( Chat.poll, 0 );
    }
  };

  /* If we're currently in delayed-retry mode, try to reset the delay
     if we're waiting for a while for the connection to complete,
     as that's an indication (not a guaranty) that we're connected
     and long-polling. */
  const setupConnectionReestablished = function(){
    if( !Chat.timer.idReconnect && Chat.timer.isDelayed() ){
      Chat.timer.idReconnect = setTimeout(()=>{
        Chat.timer.idReconnect = 0;
        if( poll.running ){
          reportConnectionReestablished();
        }
      }, Chat.timer.$initialDelay * 5 );
      Chat.e.viewMessages.querySelectorAll(
        '.message-widget.error-connection'
      ).forEach(e=>D.remove(e));
    }
  };

  /**
     Submits the contents of the message input field (if not empty)
     and/or the file attachment field to the server. If both are
     empty, this is a no-op.

     If the current view is the history search, this instead sends the

    if( !msg && !file ) return;
    fallback.blob = file;
    const self = this;
    fd.set("lmtime", localTime8601(new Date()));
    F.fetch("chat-send",{
      payload: fd,
      responseType: 'text',
      beforesend: function(){
        Chat.ajaxStart();
        setupConnectionReestablished();
      },
      onerror:function(err){
        self.reportErrorAsMessage(err);
        recoverFailedMessage(fallback);
      },
      onload:function(txt){
        reportConnectionReestablished();
        if(!txt) return/*success response*/;
        try{
          const json = JSON.parse(txt);
          self.newContent({msgs:[json]});
        }catch(e){
          self.reportError(e);
        }

                      term );
          }
        }
      }
    );
  }/*Chat.submitSearch()*/;

  /**
     Deal with the last poll() response and maybe re-start poll().
  */
  const afterFetch = function f(){
  const afterPollFetch = function f(isOkay = true){
    if(true===f.isFirstCall){
      f.isFirstCall = false;
      Chat.ajaxEnd();
      Chat.e.viewMessages.classList.remove('loading');
      setTimeout(function(){
        Chat.scrollMessagesTo(1);
      }, 250);
    }
    if(Chat.timer.id) {
      clearTimeout(Chat.timer.id);
      Chat.timer.id = 0;
    }
    if(Chat._gotServerError && Chat.intervalTimer){
    if(Chat._gotServerError){
      clearInterval(Chat.intervalTimer);
      Chat.reportErrorAsMessage(
        "Shutting down chat poller due to server-side error. ",
        "Reload this page to reactivate it.");
      delete Chat.intervalTimer;
    }
    poll.running = false;
      Chat.timer.id = undefined;
      poll.running = false;
    } else {
      poll.running = false;
      if( isOkay ){
        Chat.timer.id = setTimeout(
          poll, Chat.timer.resetDelay()
        );
      }else{
        const delay = Chat.timer.incrDelay();
        const msg = D.addClass(
          Chat.reportErrorAsMessage(
            "Connection error. Retrying in ",
            delay, " ms.").e.body,
          'error-connection'
        );
        Chat.timer.id = setTimeout(()=>{
          D.remove(msg);
          poll();
        }, delay);
      }
      //console.log("isOkay =",isOkay,"currentDelay =",Chat.timer.currentDelay);
    }
  };
  afterFetch.isFirstCall = true;
  afterPollFetch.isFirstCall = true;

  /**
     FIXME: when polling fails because the remote server is
     reachable but it's not accepting HTTP requests, we should back
     off on polling for a while. e.g. if the remote web server process
     is killed, the poll fails quickly and immediately retries,
     hammering the remote server until the httpd is back up. That
     happens often during development of this application.

    if(true===f.isFirstCall){
      f.isFirstCall = false;
      Chat.ajaxStart();
      Chat.e.viewMessages.classList.add('loading');
    }
    F.fetch("chat-poll",{
      timeout: 420 * 1000/*FIXME: get the value from the server*/,
      //timeout: 8000,
      urlParams:{
        name: Chat.mxMsg
      },
      responseType: "json",
      // Disable the ajax start/end handling for this long-polling op:
      beforesend: function(){},
      aftersend: function(){},
      beforesend: function(){
        setupConnectionReestablished();
      },
      aftersend: function(){
      },
      onerror:function(err){
        Chat._isBatchLoading = false;
        if(Chat.verboseErrors) console.error(err);
        if(Chat.verboseErrors) console.error("poll onerror:",err);
        /* ^^^ we don't use Chat.reportError() here b/c the polling
           fails exepectedly when it times out, but is then immediately
           resumed, and reportError() produces a loud error message. */
        afterFetch();
        afterPollFetch(false);
      },
      onload:function(y){
        reportConnectionReestablished();
        newcontent(y);
        if(Chat._isBatchLoading){
          Chat._isBatchLoading = false;
          Chat.updateActiveUserList();
        }
        afterFetch();
        afterPollFetch(true);
      }
    });
  };
  poll.isFirstCall = true;
  Chat.poll = poll;
  Chat._gotServerError = poll.running = false;
  if( window.fossil.config.chat.fromcli ){
    Chat.chatOnlyMode(true);
  }
  Chat.intervalTimer = setInterval(poll, 1000);
  Chat.timer.id = setTimeout(poll, Chat.timer.resetDelay());
  delete ForceResizeKludge.$disabled;
  ForceResizeKludge();
  Chat.animate.$disabled = false;
  setTimeout( ()=>Chat.inputFocus(), 0 );
  F.page.chat = Chat/* enables testing the APIs via the dev tools */;
});