_renderRoots() {
    let { _roots: roots, _env: env, _removedRoots: removedRoots } = this;
    let globalShouldReflush = false;
    let initialRootsLength: number;

    do {
      env.begin();
      try {
        // ensure that for the first iteration of the loop
        // each root is processed
        initialRootsLength = roots.length;
        globalShouldReflush = false;

        for (let i = 0; i < roots.length; i++) {
          let root = roots[i];

          if (root.destroyed) {
            // add to the list of roots to be removed
            // they will be removed from `this._roots` later
            removedRoots.push(root);

            // skip over roots that have been marked as destroyed
            continue;
          }

          let { shouldReflush } = root;

          // when processing non-initial reflush loops,
          // do not process more roots than needed
          if (i >= initialRootsLength && !shouldReflush) {
            continue;
          }

          root.options.alwaysRevalidate = shouldReflush;
          // track shouldReflush based on this roots render result
          shouldReflush = root.shouldReflush = runInTransaction(root, 'render');

          // globalShouldReflush should be `true` if *any* of
          // the roots need to reflush
          globalShouldReflush = globalShouldReflush || shouldReflush;
        }

        this._lastRevision = CURRENT_TAG.value();
      } finally {
        env.commit();
      }
    } while (globalShouldReflush || roots.length > initialRootsLength);

    // remove any roots that were destroyed during this transaction
    while (removedRoots.length) {
      let root = removedRoots.pop();

      let rootIndex = roots.indexOf(root!);
      roots.splice(rootIndex, 1);
    }

    if (this._roots.length === 0) {
      deregister(this);
    }
  }

  _renderRootsTransaction() {
    if (this._isRenderingRoots) {
      // currently rendering roots, a new root was added and will
      // be processed by the existing _renderRoots invocation
      return;
    }

    // used to prevent calling _renderRoots again (see above)
    // while we are actively rendering roots
    this._isRenderingRoots = true;

    let completedWithoutError = false;
    try {
      this._renderRoots();
      completedWithoutError = true;
    } finally {
      if (!completedWithoutError) {
        this._lastRevision = CURRENT_TAG.value();
        if (this._env.inTransaction === true) {
          this._env.commit();
        }
      }
      this._isRenderingRoots = false;
    }
  }

export function flushInvalidActiveObservers(shouldSchedule = true) {
  if (lastKnownRevision === CURRENT_TAG.value()) {
    return;
  }

  lastKnownRevision = CURRENT_TAG.value();

  ACTIVE_OBSERVERS.forEach((activeObservers, target) => {
    let meta = peekMeta(target);

    if (meta && (meta.isSourceDestroying() || meta.isMetaDestroyed())) {
      ACTIVE_OBSERVERS.delete(target);
      return;
    }

    activeObservers.forEach((observer, eventName) => {
      if (!observer.tag.validate(observer.lastRevision)) {
        let sendObserver = () => {
          try {
            sendEvent(target, eventName, [target, observer.path]);
          } finally {
            observer.tag = getChainTagsForKey(target, observer.path);
            observer.lastRevision = observer.tag.value();
          }
        };

        if (shouldSchedule) {
          schedule('actions', sendObserver);
        } else {
          // TODO: we need to schedule eagerly in exactly one location (_internalReset),
          // for query params. We should get rid of this ASAP
          sendObserver();
        }
      }
    });
  });
}

 _isValid() {
   return this._destroyed || this._roots.length === 0 || CURRENT_TAG.validate(this._lastRevision);
 }