watcher.on(actions.openTabForwardHistory, async (store, action) => {
    const { wind, tab, clientX, clientY } = action.payload;
    const space = Space.fromStore(store, wind, tab);
    if (!space.canGoForward()) {
      return;
    }

    let startIndex = space.currentIndex() + 1;
    let endIndex = space.history().length;
    if (endIndex - startIndex > shownHistoryItems) {
      endIndex = startIndex + shownHistoryItems;
    }

    const template = makeHistoryTemplate({
      i18n: store.getState().i18n,
      wind,
      space,
      startIndex,
      endIndex,
      dir: 1,
    });
    store.dispatch(
      actions.popupContextMenu({ wind, clientX, clientY, template })
    );
  });

  watcher.on(actions.tabParamsChanged, async (store, action) => {
    let { tab, params, window } = action.payload;
    const sp = Space.fromStore(store, window, tab);

    const newParams = {
      ...sp.query(),
      ...params,
    };

    const previousURL = sp.url();
    const parsed = nodeURL.parse(previousURL);
    const { host, protocol, pathname } = parsed;
    const newURL = nodeURL.format({
      host,
      protocol,
      pathname,
      slashes: true,
      search: `?${querystring.stringify(newParams)}`,
    });

    store.dispatch(
      actions.evolveTab({
        window,
        tab,
        url: newURL,
        replace: true,
        onlyParamsChange: true,
      })
    );
  });

 let printStateHistory = () => {
   const space = Space.fromStore(store, wind, tab);
   logger.debug(`---------------------------------`);
   for (let i = 0; i < space.history().length; i++) {
     const page = space.history()[i];
     logger.debug(`S| ${i === space.currentIndex() ? ">" : " "} ${page.url}`);
   }
 };

  items = map(openTabs, id => {
    const ti = tabInstances[id];
    if (!ti) {
      return null;
    }

    const sp = Space.fromInstance(ti);
    const { history, currentIndex } = ti;
    const savedLabel = sp.label();
    return { id, history, currentIndex, savedLabel };
  });

  watcher.on(actions.commandMain, async (store, action) => {
    const { window } = action.payload;
    const { tab } = store.getState().windows[window].navigation;
    const sp = Space.fromStore(store, window, tab);

    if (sp.prefix === "games") {
      const game = sp.game();
      if (game) {
        // FIXME: queueGame doesn't always do the right thing.
        // it'll try installing even if there's no chance you'll be able
        // to download it (for example, if you need to purchase it first)
        store.dispatch(actions.queueGame({ game }));
      }
    }
  });

  watcher.on(actions.openTabContextMenu, async (store, action) => {
    const { window, tab } = action.payload;

    let template: IMenuTemplate;
    template = concatTemplates(template, newTabControls(store, window, tab));

    const sp = Space.fromStore(store, window, tab);
    if (sp.prefix === "games") {
      const game = sp.game();
      if (game && game.id) {
        template = concatTemplates(template, gameControls(store, game));
      }
    }

    template = concatTemplates(template, closeTabControls(store, window, tab));
    const { clientX, clientY } = action.payload;
    openMenu(store, template, { window, clientX, clientY });
  });

function withWebContents<T>(
  store: IStore,
  window: string,
  tab: string,
  cb: WebContentsCallback<T>
): T | null {
  const sp = Space.fromStore(store, window, tab);

  const { webContentsId } = sp.web();
  if (!webContentsId) {
    return null;
  }

  const wc = webContents.fromId(webContentsId);
  if (!wc || wc.isDestroyed()) {
    return null;
  }

  return cb(wc as ExtendedWebContents);
}

function getFetcherClass(
  store: IStore,
  window: string,
  tab: string
): typeof Fetcher {
  const sp = Space.fromStore(store, window, tab);

  switch (sp.internalPage()) {
    case "dashboard":
      return DashboardFetcher;
    case "collections": {
      if (sp.firstPathElement()) {
        return CollectionFetcher;
      } else {
        return CollectionsFetcher;
      }
    }
    case "dashboard":
      return DashboardFetcher;
    case "library":
      return LibraryFetcher;
    case "games":
      return GameFetcher;
    case "collections":
      return CollectionFetcher;
    case "locations":
      return LocationFetcher;
    case "applog":
      return AppLogFetcher;
  }

  switch (sp.prefix) {
    case "games":
      return GameFetcher;
  }
  return null;
}

    withWebContents(store, wind, tab, wc => {
      let offset = index - oldIndex;
      const url = rs.winds[wind].tabInstances[tab].history[index].url;
      if (
        wc.canGoToOffset(offset) &&
        wc.history[wc.currentIndex + offset] === url
      ) {
        logger.debug(`\n`);
        logger.debug(`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`);
        logger.debug(
          `For index ${oldIndex} => ${index}, applying offset ${offset}`
        );
        logger.debug(`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n`);
        wc.goToOffset(offset);
      } else {
        const url = Space.fromState(rs, wind, tab).url();
        logger.debug(`\n`);
        logger.debug(`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`);
        logger.debug(
          `For index ${oldIndex} => ${index}, clearing history and loading ${url}`
        );
        logger.debug(`(could go to offset? ${wc.canGoToOffset(offset)})`);
        logger.debug(`(wcl = ${wc.history[wc.currentIndex + offset]})`);
        logger.debug(`(url = ${url})`);

        if (offset == 1) {
          logger.debug(
            `Wait, no, we're just going forward one, we don't need to clear history`
          );
        } else {
          wc.clearHistory();
        }
        logger.debug(`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n`);
        loadURL(wc, url);
      }
    });