diff --git a/crates/brk_cli/src/run.rs b/crates/brk_cli/src/run.rs
index 148cb0f1a..fa3afff07 100644
--- a/crates/brk_cli/src/run.rs
+++ b/crates/brk_cli/src/run.rs
@@ -128,7 +128,7 @@ pub struct RunConfig {
     #[arg(short, long)]
     computation: Option<Computation>,
 
-    /// Activate compression of datasets, set to true to save disk space or false if prioritize speed, default: true, saved
+    /// Activate compression of datasets, set to true to save disk space or false if prioritize speed, default: compressed, saved
     #[arg(short, long, value_name = "FORMAT")]
     format: Option<Format>,
 
diff --git a/websites/default/packages/lightweight-charts/wrapper.js b/websites/default/packages/lightweight-charts/wrapper.js
index 17d8a62b2..25458af0c 100644
--- a/websites/default/packages/lightweight-charts/wrapper.js
+++ b/websites/default/packages/lightweight-charts/wrapper.js
@@ -45,7 +45,7 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
    * @param {Accessor<Index>} args.index
    * @param {((unknownTimeScaleCallback: VoidFunction) => void)} [args.timeScaleSetCallback]
    * @param {Owner | null} args.owner
-   * @param {true} [args.fitContentOnResize]
+   * @param {true} [args.fitContent]
    * @param {{unit: Unit; blueprints: AnySeriesBlueprint[]}[]} [args.config]
    */
   function createChartElement({
@@ -54,16 +54,14 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
     colors,
     utils,
     elements,
-    id,
+    id: chartId,
     index,
     vecsResources,
     timeScaleSetCallback,
     owner: _owner,
-    fitContentOnResize,
+    fitContent,
     config,
   }) {
-    const owner = _owner || signals.getOwner();
-
     const div = window.document.createElement("div");
     div.classList.add("chart");
     parent.append(div);
@@ -71,7 +69,6 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
     const legendTop = createLegend({
       utils,
       signals,
-      paneIndex: 0,
     });
     div.append(legendTop.element);
 
@@ -82,7 +79,6 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
     const legendBottom = createLegend({
       utils,
       signals,
-      paneIndex: 1,
     });
     div.append(legendBottom.element);
 
@@ -107,6 +103,11 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         },
         timeScale: {
           borderVisible: false,
+          ...(fitContent
+            ? {
+                minBarSpacing: 0.001,
+              }
+            : {}),
         },
         localization: {
           priceFormatter: numberToShortUSFormat,
@@ -115,13 +116,10 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         crosshair: {
           mode: 3,
         },
-        ...(fitContentOnResize
+        ...(fitContent
           ? {
-              handleScroll: false,
               handleScale: false,
-              timeScale: {
-                minBarSpacing: 0.001,
-              },
+              handleScroll: false,
             }
           : {}),
         // ..._options,
@@ -160,7 +158,11 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
       },
     );
 
+    let timeScaleSet = false;
+
     signals.createEffect(index, (index) => {
+      timeScaleSet = false;
+
       ichart.applyOptions({
         timeScale: {
           timeVisible:
@@ -169,7 +171,7 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
             index === /** @satisfies {HalvingEpoch} */ (4),
         },
       });
-      if (!fitContentOnResize) {
+      if (!fitContent) {
         ichart.applyOptions({
           timeScale: {
             minBarSpacing:
@@ -196,19 +198,7 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
       }),
     );
 
-    const timeResource = signals.createMemo(() => {
-      const i = index();
-      const timeResource = vecsResources.getOrCreate(
-        i,
-        i === /** @satisfies {Height} */ (5) ? "timestamp-fixed" : "timestamp",
-      );
-      timeResource.fetch();
-      return timeResource;
-    });
-
-    let timeScaleSet = false;
-
-    if (fitContentOnResize) {
+    if (fitContent) {
       new ResizeObserver(() => ichart.timeScale().fitContent()).observe(
         chartDiv,
       );
@@ -220,43 +210,47 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
      * @param {number} args.paneIndex
      * @param {"nw" | "ne" | "se" | "sw"} args.position
      * @param {number} [args.timeout]
-     * @param {(args: {owner: Owner | null, pane: IPaneApi<Time>}) => HTMLElement} args.createChild
+     * @param {(pane: IPaneApi<Time>) => HTMLElement} args.createChild
      */
     function addFieldsetIfNeeded({ paneIndex, id, position, createChild }) {
       const owner = signals.getOwner();
+
       setTimeout(
-        () => {
-          const parent = ichart
-            ?.panes()
-            .at(paneIndex)
-            ?.getHTMLElement()
-            .children?.item(1)?.firstChild;
+        () =>
+          signals.runWithOwner(owner, () => {
+            const parent = ichart
+              ?.panes()
+              .at(paneIndex)
+              ?.getHTMLElement()
+              .children?.item(1)?.firstChild;
 
-          if (!parent) throw Error("Parent should exist");
+            if (!parent) throw Error("Parent should exist");
 
-          if (
-            Array.from(parent.childNodes).filter(
+            const children = Array.from(parent.childNodes).filter(
               (element) =>
                 /** @type {HTMLElement} */ (element).dataset.position ===
                 position,
-            ).length
-          ) {
-            return;
-          }
+            );
 
-          const fieldset = window.document.createElement("fieldset");
-          fieldset.dataset.size = "xs";
-          fieldset.dataset.position = position;
-          fieldset.id = `${id}-${paneIndex}`;
-          const pane = ichart.panes().at(paneIndex);
-          if (!pane) throw Error("Expect pane");
-          pane
-            .getHTMLElement()
-            .children?.item(1)
-            ?.firstChild?.appendChild(fieldset);
+            if (children.length === 1) {
+              children[0].remove();
+            } else if (children.length > 1) {
+              throw Error("Unreacable");
+            }
 
-          fieldset.append(createChild({ owner, pane }));
-        },
+            const fieldset = window.document.createElement("fieldset");
+            fieldset.dataset.size = "xs";
+            fieldset.dataset.position = position;
+            fieldset.id = `${id}-${paneIndex}`;
+            const pane = ichart.panes().at(paneIndex);
+            if (!pane) throw Error("Expect pane");
+            pane
+              .getHTMLElement()
+              .children?.item(1)
+              ?.firstChild?.appendChild(fieldset);
+
+            fieldset.append(createChild(pane));
+          }),
         paneIndex ? 50 : 0,
       );
     }
@@ -264,40 +258,32 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
     /**
      * @param {Object} args
      * @param {Unit} args.unit
-     * @param {string} args.id
      * @param {SeriesType} args.seriesType
      * @param {number} args.paneIndex
      */
-    function addPriceScaleSelectorIfNeeded({
-      unit,
-      paneIndex,
-      id,
-      seriesType,
-    }) {
-      id = `${id}-scale`;
+    function addPriceScaleSelectorIfNeeded({ unit, paneIndex, seriesType }) {
+      const id = `${chartId}-scale`;
 
       addFieldsetIfNeeded({
         id,
         paneIndex,
         position: "sw",
-        createChild({ owner, pane }) {
+        createChild(pane) {
           const { field, selected } = utils.dom.createHorizontalChoiceField({
             choices: /** @type {const} */ (["lin", "log"]),
-            id: utils.stringToId(`${id} ${unit}`),
+            id: utils.stringToId(`${id} ${paneIndex} ${unit}`),
             defaultValue:
               unit === "USD" && seriesType !== "Baseline" ? "log" : "lin",
             key: `${id}-price-scale-${paneIndex}`,
             signals,
           });
 
-          signals.runWithOwner(owner, () => {
-            signals.createEffect(selected, (selected) => {
-              try {
-                pane.priceScale("right").applyOptions({
-                  mode: selected === "lin" ? 0 : 1,
-                });
-              } catch {}
-            });
+          signals.createEffect(selected, (selected) => {
+            try {
+              pane.priceScale("right").applyOptions({
+                mode: selected === "lin" ? 0 : 1,
+              });
+            } catch {}
           });
 
           return field;
@@ -352,6 +338,9 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
 
         iseries.setSeriesOrder(order);
 
+        /** @type {VecResource | undefined} */
+        let _valuesResource;
+
         /** @type {Series} */
         const series = {
           inner: iseries,
@@ -360,12 +349,25 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
           remove() {
             dispose();
             chart.inner.removeSeries(iseries);
+            if (_valuesResource) {
+              activeResources.delete(_valuesResource);
+            }
           },
         };
 
         if (vecId) {
           signals.createEffect(index, (index) => {
+            const timeResource = vecsResources.getOrCreate(
+              index,
+              index === /** @satisfies {Height} */ (5)
+                ? "timestamp-fixed"
+                : "timestamp",
+            );
+            timeResource.fetch();
+
             const valuesResource = vecsResources.getOrCreate(index, vecId);
+            _valuesResource = valuesResource;
+
             url = valuesResource.url;
             signals.createEffect(active, (active) => {
               if (active) {
@@ -375,25 +377,29 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
                 const fetchedKey = vecsResources.defaultFetchedKey;
                 signals.createEffect(
                   () => [
-                    timeResource().fetched[fetchedKey].vec(),
+                    timeResource.fetched[fetchedKey].vec(),
                     valuesResource.fetched[fetchedKey].vec(),
                   ],
                   ([indexes, _ohlcs]) => {
                     if (!indexes || !_ohlcs) return;
+
+                    const seriesData = series.inner.data();
+                    // const set = seriesData.length === 0;
+
                     const ohlcs = /** @type {OHLCTuple[]} */ (_ohlcs);
                     let length = Math.min(indexes.length, ohlcs.length);
                     const data = new Array(length);
                     let prevTime = null;
-                    let offset = 0;
+                    let timeOffset = 0;
 
                     for (let i = 0; i < length; i++) {
                       const time = indexes[i];
                       const sameTime = prevTime === time;
                       if (sameTime) {
-                        offset += 1;
+                        timeOffset += 1;
                       }
                       const v = ohlcs[i];
-                      const offsetedI = i - offset;
+                      const offsetedI = i - timeOffset;
                       if (v === null) {
                         data[offsetedI] = {
                           time,
@@ -425,8 +431,21 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
                       prevTime = time;
                     }
 
-                    data.length -= offset;
-                    series.inner.setData(data);
+                    data.length -= timeOffset;
+
+                    // if (set) {
+                    iseries.setData(data);
+
+                    if (fitContent) {
+                      ichart.timeScale().fitContent();
+                    }
+                    // } else {
+                    // let seriesDataOffset = 0;
+                    // while seriesData
+                    //   data.forEach((bar) => {
+                    //     iseries.update(bar, true);
+                    //   });
+                    // }
 
                     timeScaleSetCallback?.(() => {
                       if (
@@ -452,6 +471,10 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         } else if (data) {
           signals.createEffect(data, (data) => {
             iseries.setData(data);
+
+            if (fitContent) {
+              ichart.timeScale().fitContent();
+            }
           });
         }
 
@@ -473,7 +496,6 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         addPriceScaleSelectorIfNeeded({
           paneIndex,
           seriesType,
-          id,
           unit,
         });
 
@@ -505,15 +527,11 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         name,
         unit,
         order,
-        paneIndex: _paneIndex,
+        paneIndex = 0,
         defaultActive,
         data,
         inverse,
       }) {
-        const paneIndex = _paneIndex ?? 0;
-
-        if (!timeResource) throw Error("Chart not fully set");
-
         const green = inverse ? colors.red : colors.green;
         const red = inverse ? colors.green : colors.red;
         const iseries = ichart.addSeries(
@@ -560,15 +578,11 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         unit,
         order,
         color,
-        paneIndex: _paneIndex,
+        paneIndex = 0,
         defaultActive,
         data,
         options,
       }) {
-        if (!ichart || !timeResource) throw Error("Chart not fully set");
-
-        const paneIndex = _paneIndex ?? 0;
-
         color ||= unit === "USD" ? colors.green : colors.orange;
 
         const iseries = ichart.addSeries(
@@ -622,8 +636,6 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
         data,
         options,
       }) {
-        if (!ichart || !timeResource) throw Error("Chart not fully set");
-
         const paneIndex = _paneIndex ?? 0;
 
         const iseries = ichart.addSeries(
@@ -668,18 +680,6 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
           vecId,
         });
       },
-      // /**
-      //  *
-      //  * @param {Object} args
-      //  * @param {Owner | null} args.owner
-      //  */
-      // reset({ owner: _owner }) {
-      //   owner = _owner;
-      //   timeScaleSet = false;
-      //   activeResources.length = 0;
-      //   legendTop.reset();
-      //   legendBottom.reset();
-      // },
     };
 
     config?.forEach(({ unit, blueprints }, paneIndex) => {
@@ -728,10 +728,9 @@ export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
 /**
  * @param {Object} args
  * @param {Signals} args.signals
- * @param {number} args.paneIndex
  * @param {Utilities} args.utils
  */
-function createLegend({ signals, utils, paneIndex }) {
+function createLegend({ signals, utils }) {
   const element = window.document.createElement("legend");
 
   const hovered = signals.createSignal(/** @type {Series | null} */ (null));
@@ -739,18 +738,6 @@ function createLegend({ signals, utils, paneIndex }) {
   /** @type {HTMLElement[]} */
   const legends = [];
 
-  // /** @type {VoidFunction[]} */
-  // const disposes = [];
-
-  // /**
-  //  * @param {number} start
-  //  */
-  // function disposeFrom(start) {
-  //   disposes.splice(start).forEach((dispose) => dispose());
-  // }
-
-  // signals.onCleanup(() => disposeFrom(0));
-
   return {
     element,
     /**
@@ -762,15 +749,6 @@ function createLegend({ signals, utils, paneIndex }) {
      * @param {string} [args.url]
      */
     addOrReplace({ series, name, colors, url, order }) {
-      // signals.createRoot((dispose) => {
-      //   disposes.at(order)?.();
-
-      //   if (disposes.length < order) {
-      //     throw Error("Unreachable");
-      //   }
-
-      //   disposes[order] = dispose;
-
       const div = window.document.createElement("div");
 
       const prev = legends[order];
@@ -883,7 +861,6 @@ function createLegend({ signals, utils, paneIndex }) {
         anchor.title = "Click to view data";
         div.append(anchor);
       }
-      // });
     },
     /**
      * @param {number} start
@@ -991,10 +968,29 @@ function numberToShortUSFormat(value) {
   const letterIndex = Math.floor(log / 3);
   const letter = suffices[letterIndex];
 
-  return `${numberToUSFormat(
-    value / (1_000_000 * 1_000 ** letterIndex),
-    3,
-  )}${letter}`;
+  const modulused = log % 3;
+
+  // return `${numberToUSFormat(
+  //   value / (1_000_000 * 1_000 ** letterIndex),
+  //   3,
+  // )}${letter}`;
+
+  if (modulused === 0) {
+    return `${numberToUSFormat(
+      value / (1_000_000 * 1_000 ** letterIndex),
+      3,
+    )}${letter}`;
+  } else if (modulused === 1) {
+    return `${numberToUSFormat(
+      value / (1_000_000 * 1_000 ** letterIndex),
+      2,
+    )}${letter}`;
+  } else {
+    return `${numberToUSFormat(
+      value / (1_000_000 * 1_000 ** letterIndex),
+      1,
+    )}${letter}`;
+  }
 }
 
 /**
diff --git a/websites/default/packages/solid-signals/wrapper.js b/websites/default/packages/solid-signals/wrapper.js
index a68d92071..ee4a52c49 100644
--- a/websites/default/packages/solid-signals/wrapper.js
+++ b/websites/default/packages/solid-signals/wrapper.js
@@ -23,17 +23,21 @@ const importSignals = import("./v0.3.2-treeshaked/script.js").then(
         (compute, effect) => {
           let dispose = /** @type {VoidFunction | null} */ (null);
 
+          if (_signals.getOwner() === null) {
+            throw Error("No owner");
+          }
+
           function cleanup() {
             if (dispose) {
               dispose();
               dispose = null;
-              console.log("effectCount = ", --effectCount);
+              console.debug("effectCount = ", --effectCount);
             }
           }
 
           // @ts-ignore
           _signals.createEffect(compute, (v, oldV) => {
-            console.log("effectCount = ", ++effectCount);
+            console.debug("effectCount = ", ++effectCount);
             cleanup();
             signals.createRoot((_dispose) => {
               dispose = _dispose;
diff --git a/websites/default/scripts/chart.js b/websites/default/scripts/chart.js
index 69b1d1574..c9d91a90b 100644
--- a/websites/default/scripts/chart.js
+++ b/websites/default/scripts/chart.js
@@ -67,6 +67,9 @@ export function init({
     elements,
     index,
     timeScaleSetCallback: (unknownTimeScaleCallback) => {
+      // TODO: Although it mostly works in practice, need to make it more robust, there is no guarantee that this runs in order and wait for `from` and `to` to update when `index` and thus `TIMERANGE_LS_KEY` is updated
+      // Need to have the right values before the update
+
       const from_ = from();
       const to_ = to();
       if (from_ !== null && to_ !== null) {
@@ -96,11 +99,7 @@ export function init({
       defaultValue: "Line",
       keyPrefix,
       key: "seriestype-0",
-      choices: /** @type {const} */ ([
-        // "Auto",
-        "Candles",
-        "Line",
-      ]),
+      choices: /** @type {const} */ (["Candles", "Line"]),
       signals,
     });
 
diff --git a/websites/default/scripts/main.js b/websites/default/scripts/main.js
index 672c4a8f8..0000c8b73 100644
--- a/websites/default/scripts/main.js
+++ b/websites/default/scripts/main.js
@@ -1261,7 +1261,7 @@ function createUtils() {
         cache = await caches.open(CACHE_NAME);
         const cachedResponse = await cache.match(url);
         if (cachedResponse) {
-          console.log(`cache: ${url}`);
+          console.debug(`cache: ${url}`);
           const json = /** @type {T} */ await cachedResponse.json();
           cachedJson = json;
           callback(json);
@@ -1298,7 +1298,7 @@ function createUtils() {
 
         if (!fetchedJson) return cachedJson;
 
-        console.log(`fetch: ${url}`);
+        console.debug(`fetch: ${url}`);
 
         if (Array.isArray(cachedJson) && Array.isArray(fetchedJson)) {
           const previousLength = cachedJson?.length || 0;
@@ -2005,559 +2005,578 @@ function main() {
 
   packages.signals().then((signals) =>
     vecidToIndexesPromise.then(({ createVecIdToIndexes, VERSION }) =>
-      optionsPromise.then(async ({ initOptions }) => {
-        console.log(`VERSION = ${VERSION}`);
+      optionsPromise.then(async ({ initOptions }) =>
+        signals.createRoot(() => {
+          const owner = signals.getOwner();
 
-        const vecIdToIndexes = createVecIdToIndexes();
+          console.log(`VERSION = ${VERSION}`);
 
-        if (env.localhost) {
-          Object.keys(vecIdToIndexes).forEach((id) => {
-            utils.vecidToUnit(/** @type {VecId} */ (id));
-          });
-        }
+          const vecIdToIndexes = createVecIdToIndexes();
 
-        function initDark() {
-          const preferredColorSchemeMatchMedia = window.matchMedia(
-            "(prefers-color-scheme: dark)",
-          );
-          const dark = signals.createSignal(
-            preferredColorSchemeMatchMedia.matches,
-          );
-          preferredColorSchemeMatchMedia.addEventListener(
-            "change",
-            ({ matches }) => {
-              dark.set(matches);
-            },
-          );
-          return dark;
-        }
-        const dark = initDark();
-
-        const qrcode = signals.createSignal(
-          /** @type {string | null} */ (null),
-        );
-
-        function createLastHeightResource() {
-          const lastHeight = signals.createSignal(0);
-          function fetchLastHeight() {
-            utils.api.fetchLast(
-              (h) => {
-                lastHeight.set(h);
-              },
-              /** @satisfies {Height} */ (5),
-              "height",
-            );
+          if (env.localhost) {
+            Object.keys(vecIdToIndexes).forEach((id) => {
+              utils.vecidToUnit(/** @type {VecId} */ (id));
+            });
           }
-          fetchLastHeight();
-          setInterval(fetchLastHeight, 10_000);
-          return lastHeight;
-        }
-        const lastHeight = createLastHeightResource();
 
-        const webSockets = initWebSockets(signals, utils);
-
-        const vecsResources = createVecsResources(signals, utils);
-
-        const colors = createColors(dark, elements);
-
-        const options = initOptions({
-          colors,
-          env,
-          signals,
-          utils,
-          webSockets,
-          qrcode,
-        });
-
-        // const urlSelected = utils.url.pathnameToSelectedId();
-        // function createWindowPopStateEvent() {
-        //   window.addEventListener("popstate", (event) => {
-        //     const urlSelected = utils.url.pathnameToSelectedId();
-        //     const option = options.list.find((option) => urlSelected === option.id);
-        //     if (option) {
-        //       options.selected.set(option);
-        //     }
-        //   });
-        // }
-        // createWindowPopStateEvent();
-
-        function initSelected() {
-          function initSelectedFrame() {
-            console.log("selected: init");
-
-            const chartOption = signals.createSignal(
-              /** @type {ChartOption | null} */ (null),
+          function initDark() {
+            const preferredColorSchemeMatchMedia = window.matchMedia(
+              "(prefers-color-scheme: dark)",
             );
-            const simOption = signals.createSignal(
-              /** @type {SimulationOption | null} */ (null),
+            const dark = signals.createSignal(
+              preferredColorSchemeMatchMedia.matches,
             );
-
-            const owner = signals.getOwner();
-
-            let previousElement = /** @type {HTMLElement | undefined} */ (
-              undefined
+            preferredColorSchemeMatchMedia.addEventListener(
+              "change",
+              ({ matches }) => {
+                dark.set(matches);
+              },
             );
-            let firstTimeLoadingChart = true;
-            let firstTimeLoadingTable = true;
-            let firstTimeLoadingSimulation = true;
+            return dark;
+          }
+          const dark = initDark();
 
-            signals.createEffect(options.selected, (option) => {
-              if (previousElement) {
-                previousElement.hidden = true;
-                utils.url.resetParams(option);
-                utils.url.pushHistory(option.id);
-              } else {
-                utils.url.replaceHistory({ pathname: option.id });
-              }
+          const qrcode = signals.createSignal(
+            /** @type {string | null} */ (null),
+          );
 
-              /** @type {HTMLElement} */
-              let element;
+          function createLastHeightResource() {
+            const lastHeight = signals.createSignal(0);
+            function fetchLastHeight() {
+              utils.api.fetchLast(
+                (h) => {
+                  lastHeight.set(h);
+                },
+                /** @satisfies {Height} */ (5),
+                "height",
+              );
+            }
+            fetchLastHeight();
+            setInterval(fetchLastHeight, 10_000);
+            return lastHeight;
+          }
+          const lastHeight = createLastHeightResource();
 
-              switch (option.kind) {
-                case "chart": {
-                  element = elements.charts;
+          const webSockets = initWebSockets(signals, utils);
 
-                  chartOption.set(option);
+          const vecsResources = createVecsResources(signals, utils);
 
-                  if (firstTimeLoadingChart) {
-                    const lightweightCharts = packages.lightweightCharts();
-                    const chartScript = import("./chart.js");
-                    utils.dom.importStyleAndThen("/styles/chart.css", () =>
-                      chartScript.then(({ init: initChartsElement }) =>
-                        lightweightCharts.then((lightweightCharts) =>
-                          signals.runWithOwner(owner, () =>
-                            initChartsElement({
-                              colors,
-                              elements,
-                              lightweightCharts,
-                              selected: /** @type {Accessor<ChartOption>} */ (
-                                chartOption
-                              ),
-                              signals,
-                              utils,
-                              webSockets,
-                              vecsResources,
-                              vecIdToIndexes,
-                            }),
+          const colors = createColors(dark, elements);
+
+          const options = initOptions({
+            colors,
+            env,
+            signals,
+            utils,
+            webSockets,
+            qrcode,
+          });
+
+          // const urlSelected = utils.url.pathnameToSelectedId();
+          // function createWindowPopStateEvent() {
+          //   window.addEventListener("popstate", (event) => {
+          //     const urlSelected = utils.url.pathnameToSelectedId();
+          //     const option = options.list.find((option) => urlSelected === option.id);
+          //     if (option) {
+          //       options.selected.set(option);
+          //     }
+          //   });
+          // }
+          // createWindowPopStateEvent();
+
+          function initSelected() {
+            let firstRun = true;
+            function initSelectedFrame() {
+              if (!firstRun) throw Error("Unreachable");
+              firstRun = false;
+
+              console.log("selected: init");
+
+              const owner = signals.getOwner();
+
+              const chartOption = signals.createSignal(
+                /** @type {ChartOption | null} */ (null),
+              );
+              const simOption = signals.createSignal(
+                /** @type {SimulationOption | null} */ (null),
+              );
+
+              let previousElement = /** @type {HTMLElement | undefined} */ (
+                undefined
+              );
+              let firstTimeLoadingChart = true;
+              let firstTimeLoadingTable = true;
+              let firstTimeLoadingSimulation = true;
+
+              signals.createEffect(options.selected, (option) => {
+                if (previousElement) {
+                  previousElement.hidden = true;
+                  utils.url.resetParams(option);
+                  utils.url.pushHistory(option.id);
+                } else {
+                  utils.url.replaceHistory({ pathname: option.id });
+                }
+
+                /** @type {HTMLElement} */
+                let element;
+
+                switch (option.kind) {
+                  case "chart": {
+                    element = elements.charts;
+
+                    chartOption.set(option);
+
+                    if (firstTimeLoadingChart) {
+                      const lightweightCharts = packages.lightweightCharts();
+                      const chartScript = import("./chart.js");
+                      utils.dom.importStyleAndThen("/styles/chart.css", () =>
+                        chartScript.then(({ init: initChartsElement }) =>
+                          lightweightCharts.then((lightweightCharts) =>
+                            signals.runWithOwner(owner, () =>
+                              initChartsElement({
+                                colors,
+                                elements,
+                                lightweightCharts,
+                                selected: /** @type {Accessor<ChartOption>} */ (
+                                  chartOption
+                                ),
+                                signals,
+                                utils,
+                                webSockets,
+                                vecsResources,
+                                vecIdToIndexes,
+                              }),
+                            ),
                           ),
                         ),
-                      ),
-                    );
+                      );
+                    }
+                    firstTimeLoadingChart = false;
+
+                    break;
                   }
-                  firstTimeLoadingChart = false;
+                  case "table": {
+                    element = elements.table;
 
-                  break;
-                }
-                case "table": {
-                  element = elements.table;
-
-                  if (firstTimeLoadingTable) {
-                    const tableScript = import("./table.js");
-                    utils.dom.importStyleAndThen("/styles/table.css", () =>
-                      tableScript.then(({ init }) =>
-                        signals.runWithOwner(owner, () =>
-                          init({
-                            colors,
-                            elements,
-                            signals,
-                            utils,
-                            vecsResources,
-                            option,
-                            vecIdToIndexes,
-                          }),
-                        ),
-                      ),
-                    );
-                  }
-                  firstTimeLoadingTable = false;
-
-                  break;
-                }
-                case "simulation": {
-                  element = elements.simulation;
-
-                  simOption.set(option);
-
-                  if (firstTimeLoadingSimulation) {
-                    const lightweightCharts = packages.lightweightCharts();
-                    const simulationScript = import("./simulation.js");
-                    utils.dom.importStyleAndThen("/styles/simulation.css", () =>
-                      simulationScript.then(({ init }) =>
-                        lightweightCharts.then((lightweightCharts) =>
+                    if (firstTimeLoadingTable) {
+                      const tableScript = import("./table.js");
+                      utils.dom.importStyleAndThen("/styles/table.css", () =>
+                        tableScript.then(({ init }) =>
                           signals.runWithOwner(owner, () =>
                             init({
                               colors,
                               elements,
-                              lightweightCharts,
                               signals,
                               utils,
                               vecsResources,
+                              option,
+                              vecIdToIndexes,
                             }),
                           ),
                         ),
-                      ),
-                    );
+                      );
+                    }
+                    firstTimeLoadingTable = false;
+
+                    break;
                   }
-                  firstTimeLoadingSimulation = false;
+                  case "simulation": {
+                    element = elements.simulation;
 
-                  break;
-                }
-                case "url": {
-                  return;
-                }
-              }
+                    simOption.set(option);
 
-              element.hidden = false;
-              previousElement = element;
-            });
-          }
+                    if (firstTimeLoadingSimulation) {
+                      const lightweightCharts = packages.lightweightCharts();
+                      const simulationScript = import("./simulation.js");
+                      utils.dom.importStyleAndThen(
+                        "/styles/simulation.css",
+                        () =>
+                          simulationScript.then(({ init }) =>
+                            lightweightCharts.then((lightweightCharts) =>
+                              signals.runWithOwner(owner, () =>
+                                init({
+                                  colors,
+                                  elements,
+                                  lightweightCharts,
+                                  signals,
+                                  utils,
+                                  vecsResources,
+                                }),
+                              ),
+                            ),
+                          ),
+                      );
+                    }
+                    firstTimeLoadingSimulation = false;
 
-          function createMobileSwitchEffect() {
-            let firstRun = true;
-            signals.createEffect(options.selected, () => {
-              if (!firstRun && !utils.dom.isHidden(elements.asideLabel)) {
-                elements.asideLabel.click();
-              }
-              firstRun = false;
-            });
-          }
-          createMobileSwitchEffect();
-
-          utils.dom.onFirstIntersection(elements.aside, initSelectedFrame);
-        }
-        initSelected();
-
-        function initFolders() {
-          function initTreeElement() {
-            options.treeElement.set(() => {
-              const treeElement = window.document.createElement("div");
-              treeElement.classList.add("tree");
-              elements.nav.append(treeElement);
-              return treeElement;
-            });
-          }
-
-          async function scrollToSelected() {
-            if (!options.selected()) throw "Selected should be set by now";
-            const selectedId = options.selected().id;
-
-            const path = options.selected().path;
-
-            let i = 0;
-            while (i !== path.length) {
-              try {
-                const id = path[i];
-                const details = /** @type {HTMLDetailsElement} */ (
-                  utils.dom.getElementById(id)
-                );
-                details.open = true;
-                i++;
-              } catch {
-                await utils.next();
-              }
-            }
-
-            await utils.next();
-
-            utils.dom
-              .getElementById(`${selectedId}-nav-selector`)
-              .scrollIntoView({
-                behavior: "instant",
-                block: "center",
-              });
-          }
-
-          utils.dom.onFirstIntersection(elements.nav, () => {
-            console.log("nav: init");
-            initTreeElement();
-            scrollToSelected();
-          });
-        }
-        initFolders();
-
-        function initSearch() {
-          function initSearchFrame() {
-            console.log("search: init");
-
-            const haystack = options.list.map((option) => option.title);
-
-            const RESULTS_PER_PAGE = 100;
-
-            packages.ufuzzy().then((ufuzzy) => {
-              /**
-               * @param {uFuzzy.SearchResult} searchResult
-               * @param {number} pageIndex
-               */
-              function computeResultPage(searchResult, pageIndex) {
-                /** @type {{ option: Option, title: string }[]} */
-                let list = [];
-
-                let [indexes, info, order] = searchResult || [null, null, null];
-
-                const minIndex = pageIndex * RESULTS_PER_PAGE;
-
-                if (indexes?.length) {
-                  const maxIndex = Math.min(
-                    (order || indexes).length - 1,
-                    minIndex + RESULTS_PER_PAGE - 1,
-                  );
-
-                  list = Array(maxIndex - minIndex + 1);
-
-                  for (let i = minIndex; i <= maxIndex; i++) {
-                    let index = indexes[i];
-
-                    const title = haystack[index];
-
-                    list[i % 100] = {
-                      option: options.list[index],
-                      title,
-                    };
+                    break;
                   }
-                }
-
-                return list;
-              }
-
-              /** @type {uFuzzy.Options} */
-              const config = {
-                intraIns: Infinity,
-                intraChars: `[a-z\d' ]`,
-              };
-
-              const fuzzyMultiInsert = /** @type {uFuzzy} */ (
-                ufuzzy({
-                  intraIns: 1,
-                })
-              );
-              const fuzzyMultiInsertFuzzier = /** @type {uFuzzy} */ (
-                ufuzzy(config)
-              );
-              const fuzzySingleError = /** @type {uFuzzy} */ (
-                ufuzzy({
-                  intraMode: 1,
-                  ...config,
-                })
-              );
-              const fuzzySingleErrorFuzzier = /** @type {uFuzzy} */ (
-                ufuzzy({
-                  intraMode: 1,
-                  ...config,
-                })
-              );
-
-              /** @type {VoidFunction | undefined} */
-              let dispose;
-
-              function inputEvent() {
-                signals.createRoot((_dispose) => {
-                  const needle = /** @type {string} */ (
-                    elements.searchInput.value
-                  );
-
-                  dispose?.();
-
-                  dispose = _dispose;
-
-                  elements.searchResults.scrollTo({
-                    top: 0,
-                  });
-
-                  if (!needle) {
-                    elements.searchResults.innerHTML = "";
+                  case "url": {
                     return;
                   }
+                }
 
-                  const outOfOrder = 5;
-                  const infoThresh = 5_000;
+                element.hidden = false;
+                previousElement = element;
+              });
+            }
 
-                  let result = fuzzyMultiInsert?.search(
-                    haystack,
-                    needle,
-                    undefined,
-                    infoThresh,
+            function createMobileSwitchEffect() {
+              let firstRun = true;
+              signals.createEffect(options.selected, () => {
+                if (!firstRun && !utils.dom.isHidden(elements.asideLabel)) {
+                  elements.asideLabel.click();
+                }
+                firstRun = false;
+              });
+            }
+            createMobileSwitchEffect();
+
+            utils.dom.onFirstIntersection(elements.aside, () =>
+              signals.runWithOwner(owner, initSelectedFrame),
+            );
+          }
+          initSelected();
+
+          function initFolders() {
+            function initTreeElement() {
+              options.treeElement.set(() => {
+                const treeElement = window.document.createElement("div");
+                treeElement.classList.add("tree");
+                elements.nav.append(treeElement);
+                return treeElement;
+              });
+            }
+
+            async function scrollToSelected() {
+              if (!options.selected()) throw "Selected should be set by now";
+              const selectedId = options.selected().id;
+
+              const path = options.selected().path;
+
+              let i = 0;
+              while (i !== path.length) {
+                try {
+                  const id = path[i];
+                  const details = /** @type {HTMLDetailsElement} */ (
+                    utils.dom.getElementById(id)
                   );
+                  details.open = true;
+                  i++;
+                } catch {
+                  await utils.next();
+                }
+              }
 
-                  if (!result?.[0]?.length || !result?.[1]) {
-                    result = fuzzyMultiInsert?.search(
-                      haystack,
-                      needle,
-                      outOfOrder,
-                      infoThresh,
+              await utils.next();
+
+              utils.dom
+                .getElementById(`${selectedId}-nav-selector`)
+                .scrollIntoView({
+                  behavior: "instant",
+                  block: "center",
+                });
+            }
+
+            utils.dom.onFirstIntersection(elements.nav, () => {
+              console.log("nav: init");
+              initTreeElement();
+              scrollToSelected();
+            });
+          }
+          initFolders();
+
+          function initSearch() {
+            function initSearchFrame() {
+              console.log("search: init");
+
+              const haystack = options.list.map((option) => option.title);
+
+              const RESULTS_PER_PAGE = 100;
+
+              packages.ufuzzy().then((ufuzzy) => {
+                /**
+                 * @param {uFuzzy.SearchResult} searchResult
+                 * @param {number} pageIndex
+                 */
+                function computeResultPage(searchResult, pageIndex) {
+                  /** @type {{ option: Option, title: string }[]} */
+                  let list = [];
+
+                  let [indexes, info, order] = searchResult || [
+                    null,
+                    null,
+                    null,
+                  ];
+
+                  const minIndex = pageIndex * RESULTS_PER_PAGE;
+
+                  if (indexes?.length) {
+                    const maxIndex = Math.min(
+                      (order || indexes).length - 1,
+                      minIndex + RESULTS_PER_PAGE - 1,
                     );
+
+                    list = Array(maxIndex - minIndex + 1);
+
+                    for (let i = minIndex; i <= maxIndex; i++) {
+                      let index = indexes[i];
+
+                      const title = haystack[index];
+
+                      list[i % 100] = {
+                        option: options.list[index],
+                        title,
+                      };
+                    }
                   }
 
-                  if (!result?.[0]?.length || !result?.[1]) {
-                    result = fuzzySingleError?.search(
-                      haystack,
-                      needle,
-                      outOfOrder,
-                      infoThresh,
-                    );
-                  }
+                  return list;
+                }
 
-                  if (!result?.[0]?.length || !result?.[1]) {
-                    result = fuzzySingleErrorFuzzier?.search(
-                      haystack,
-                      needle,
-                      outOfOrder,
-                      infoThresh,
-                    );
-                  }
+                /** @type {uFuzzy.Options} */
+                const config = {
+                  intraIns: Infinity,
+                  intraChars: `[a-z\d' ]`,
+                };
 
-                  if (!result?.[0]?.length || !result?.[1]) {
-                    result = fuzzyMultiInsertFuzzier?.search(
+                const fuzzyMultiInsert = /** @type {uFuzzy} */ (
+                  ufuzzy({
+                    intraIns: 1,
+                  })
+                );
+                const fuzzyMultiInsertFuzzier = /** @type {uFuzzy} */ (
+                  ufuzzy(config)
+                );
+                const fuzzySingleError = /** @type {uFuzzy} */ (
+                  ufuzzy({
+                    intraMode: 1,
+                    ...config,
+                  })
+                );
+                const fuzzySingleErrorFuzzier = /** @type {uFuzzy} */ (
+                  ufuzzy({
+                    intraMode: 1,
+                    ...config,
+                  })
+                );
+
+                /** @type {VoidFunction | undefined} */
+                let dispose;
+
+                function inputEvent() {
+                  signals.createRoot((_dispose) => {
+                    const needle = /** @type {string} */ (
+                      elements.searchInput.value
+                    );
+
+                    dispose?.();
+
+                    dispose = _dispose;
+
+                    elements.searchResults.scrollTo({
+                      top: 0,
+                    });
+
+                    if (!needle) {
+                      elements.searchResults.innerHTML = "";
+                      return;
+                    }
+
+                    const outOfOrder = 5;
+                    const infoThresh = 5_000;
+
+                    let result = fuzzyMultiInsert?.search(
                       haystack,
                       needle,
                       undefined,
                       infoThresh,
                     );
-                  }
 
-                  if (!result?.[0]?.length || !result?.[1]) {
-                    result = fuzzyMultiInsertFuzzier?.search(
-                      haystack,
-                      needle,
-                      outOfOrder,
-                      infoThresh,
-                    );
-                  }
-
-                  elements.searchResults.innerHTML = "";
-
-                  const list = computeResultPage(result, 0);
-
-                  list.forEach(({ option, title }) => {
-                    const li = window.document.createElement("li");
-                    elements.searchResults.appendChild(li);
-
-                    const element = options.createOptionElement({
-                      option,
-                      frame: "search",
-                      name: title,
-                      qrcode,
-                    });
-
-                    if (element) {
-                      li.append(element);
+                    if (!result?.[0]?.length || !result?.[1]) {
+                      result = fuzzyMultiInsert?.search(
+                        haystack,
+                        needle,
+                        outOfOrder,
+                        infoThresh,
+                      );
                     }
+
+                    if (!result?.[0]?.length || !result?.[1]) {
+                      result = fuzzySingleError?.search(
+                        haystack,
+                        needle,
+                        outOfOrder,
+                        infoThresh,
+                      );
+                    }
+
+                    if (!result?.[0]?.length || !result?.[1]) {
+                      result = fuzzySingleErrorFuzzier?.search(
+                        haystack,
+                        needle,
+                        outOfOrder,
+                        infoThresh,
+                      );
+                    }
+
+                    if (!result?.[0]?.length || !result?.[1]) {
+                      result = fuzzyMultiInsertFuzzier?.search(
+                        haystack,
+                        needle,
+                        undefined,
+                        infoThresh,
+                      );
+                    }
+
+                    if (!result?.[0]?.length || !result?.[1]) {
+                      result = fuzzyMultiInsertFuzzier?.search(
+                        haystack,
+                        needle,
+                        outOfOrder,
+                        infoThresh,
+                      );
+                    }
+
+                    elements.searchResults.innerHTML = "";
+
+                    const list = computeResultPage(result, 0);
+
+                    list.forEach(({ option, title }) => {
+                      const li = window.document.createElement("li");
+                      elements.searchResults.appendChild(li);
+
+                      const element = options.createOptionElement({
+                        option,
+                        frame: "search",
+                        name: title,
+                        qrcode,
+                      });
+
+                      if (element) {
+                        li.append(element);
+                      }
+                    });
                   });
+                }
+
+                if (elements.searchInput.value) {
+                  inputEvent();
+                }
+
+                elements.searchInput.addEventListener("input", inputEvent);
+              });
+            }
+            utils.dom.onFirstIntersection(elements.search, initSearchFrame);
+          }
+          initSearch();
+
+          function initShare() {
+            const shareDiv = utils.dom.getElementById("share-div");
+            const shareContentDiv =
+              utils.dom.getElementById("share-content-div");
+
+            shareDiv.addEventListener("click", () => {
+              qrcode.set(null);
+            });
+
+            shareContentDiv.addEventListener("click", (event) => {
+              event.stopPropagation();
+              event.preventDefault();
+            });
+
+            packages.leanQr().then(({ generate }) =>
+              signals.runWithOwner(owner, () => {
+                const imgQrcode = /** @type {HTMLImageElement} */ (
+                  utils.dom.getElementById("share-img")
+                );
+
+                const anchor = /** @type {HTMLAnchorElement} */ (
+                  utils.dom.getElementById("share-anchor")
+                );
+
+                signals.createEffect(qrcode, (qrcode) => {
+                  if (!qrcode) {
+                    shareDiv.hidden = true;
+                    return;
+                  }
+
+                  const href = qrcode;
+                  anchor.href = href;
+                  anchor.innerText =
+                    (href.startsWith("http")
+                      ? href.split("//").at(-1)
+                      : href.split(":").at(-1)) || "";
+
+                  imgQrcode.src =
+                    generate(/** @type {any} */ (href))?.toDataURL({
+                      // @ts-ignore
+                      padX: 0,
+                      padY: 0,
+                    }) || "";
+
+                  shareDiv.hidden = false;
                 });
-              }
-
-              if (elements.searchInput.value) {
-                inputEvent();
-              }
-
-              elements.searchInput.addEventListener("input", inputEvent);
-            });
-          }
-          utils.dom.onFirstIntersection(elements.search, initSearchFrame);
-        }
-        initSearch();
-
-        function initShare() {
-          const shareDiv = utils.dom.getElementById("share-div");
-          const shareContentDiv = utils.dom.getElementById("share-content-div");
-
-          shareDiv.addEventListener("click", () => {
-            qrcode.set(null);
-          });
-
-          shareContentDiv.addEventListener("click", (event) => {
-            event.stopPropagation();
-            event.preventDefault();
-          });
-
-          packages.leanQr().then(({ generate }) => {
-            const imgQrcode = /** @type {HTMLImageElement} */ (
-              utils.dom.getElementById("share-img")
+              }),
             );
+          }
+          initShare();
 
-            const anchor = /** @type {HTMLAnchorElement} */ (
-              utils.dom.getElementById("share-anchor")
-            );
+          function initDesktopResizeBar() {
+            const resizeBar = utils.dom.getElementById("resize-bar");
+            let resize = false;
+            let startingWidth = 0;
+            let startingClientX = 0;
 
-            signals.createEffect(qrcode, (qrcode) => {
-              if (!qrcode) {
-                shareDiv.hidden = true;
-                return;
+            const barWidthLocalStorageKey = "bar-width";
+
+            /**
+             * @param {number | null} width
+             */
+            function setBarWidth(width) {
+              if (typeof width === "number") {
+                elements.main.style.width = `${width}px`;
+                localStorage.setItem(barWidthLocalStorageKey, String(width));
+              } else {
+                elements.main.style.width = elements.style.getPropertyValue(
+                  "--default-main-width",
+                );
+                localStorage.removeItem(barWidthLocalStorageKey);
               }
+            }
 
-              const href = qrcode;
-              anchor.href = href;
-              anchor.innerText =
-                (href.startsWith("http")
-                  ? href.split("//").at(-1)
-                  : href.split(":").at(-1)) || "";
+            /**
+             * @param {MouseEvent} event
+             */
+            function mouseMoveEvent(event) {
+              if (resize) {
+                setBarWidth(startingWidth + (event.clientX - startingClientX));
+              }
+            }
 
-              imgQrcode.src =
-                generate(/** @type {any} */ (href))?.toDataURL({
-                  // @ts-ignore
-                  padX: 0,
-                  padY: 0,
-                }) || "";
-
-              shareDiv.hidden = false;
+            resizeBar.addEventListener("mousedown", (event) => {
+              startingClientX = event.clientX;
+              startingWidth = elements.main.clientWidth;
+              resize = true;
+              window.document.documentElement.dataset.resize = "";
+              window.addEventListener("mousemove", mouseMoveEvent);
             });
-          });
-        }
-        initShare();
 
-        function initDesktopResizeBar() {
-          const resizeBar = utils.dom.getElementById("resize-bar");
-          let resize = false;
-          let startingWidth = 0;
-          let startingClientX = 0;
+            resizeBar.addEventListener("dblclick", () => {
+              setBarWidth(null);
+            });
 
-          const barWidthLocalStorageKey = "bar-width";
-
-          /**
-           * @param {number | null} width
-           */
-          function setBarWidth(width) {
-            if (typeof width === "number") {
-              elements.main.style.width = `${width}px`;
-              localStorage.setItem(barWidthLocalStorageKey, String(width));
-            } else {
-              elements.main.style.width = elements.style.getPropertyValue(
-                "--default-main-width",
-              );
-              localStorage.removeItem(barWidthLocalStorageKey);
-            }
+            const setResizeFalse = () => {
+              resize = false;
+              delete window.document.documentElement.dataset.resize;
+              window.removeEventListener("mousemove", mouseMoveEvent);
+            };
+            window.addEventListener("mouseup", setResizeFalse);
+            window.addEventListener("mouseleave", setResizeFalse);
           }
-
-          /**
-           * @param {MouseEvent} event
-           */
-          function mouseMoveEvent(event) {
-            if (resize) {
-              setBarWidth(startingWidth + (event.clientX - startingClientX));
-            }
-          }
-
-          resizeBar.addEventListener("mousedown", (event) => {
-            startingClientX = event.clientX;
-            startingWidth = elements.main.clientWidth;
-            resize = true;
-            window.document.documentElement.dataset.resize = "";
-            window.addEventListener("mousemove", mouseMoveEvent);
-          });
-
-          resizeBar.addEventListener("dblclick", () => {
-            setBarWidth(null);
-          });
-
-          const setResizeFalse = () => {
-            resize = false;
-            delete window.document.documentElement.dataset.resize;
-            window.removeEventListener("mousemove", mouseMoveEvent);
-          };
-          window.addEventListener("mouseup", setResizeFalse);
-          window.addEventListener("mouseleave", setResizeFalse);
-        }
-        initDesktopResizeBar();
-      }),
+          initDesktopResizeBar();
+        }),
+      ),
     ),
   );
 }
diff --git a/websites/default/scripts/simulation.js b/websites/default/scripts/simulation.js
index 9445b311f..fd7eb83d6 100644
--- a/websites/default/scripts/simulation.js
+++ b/websites/default/scripts/simulation.js
@@ -705,7 +705,7 @@ export function init({
     signals,
     colors,
     id: `result`,
-    fitContentOnResize: true,
+    fitContent: true,
     vecsResources,
     utils,
     elements,
@@ -751,7 +751,7 @@ export function init({
     signals,
     colors,
     id: `bitcoin`,
-    fitContentOnResize: true,
+    fitContent: true,
     vecsResources,
     elements,
     utils,
@@ -777,7 +777,7 @@ export function init({
     signals,
     colors,
     id: `average-price`,
-    fitContentOnResize: true,
+    fitContent: true,
     vecsResources,
     utils,
     elements,
@@ -810,7 +810,7 @@ export function init({
     colors,
     vecsResources,
     id: `return-ratio`,
-    fitContentOnResize: true,
+    fitContent: true,
     utils,
     elements,
     config: [
@@ -833,7 +833,7 @@ export function init({
     signals,
     colors,
     id: `simulation-profitability-ratios`,
-    fitContentOnResize: true,
+    fitContent: true,
     vecsResources,
     utils,
     elements,
diff --git a/websites/default/styles/table.css b/websites/default/styles/table.css
index 08edef138..489c6a882 100644
--- a/websites/default/styles/table.css
+++ b/websites/default/styles/table.css
@@ -111,9 +111,10 @@
       }
     }
 
-    /* select {
-      width: 100%;
-    } */
+    select {
+      margin-right: -4px;
+      /* width: 100%; */
+    }
 
     tbody {
       text-align: right;