release: v0.0.47

server: readme: add index-t-value documentation
server: add support for /api/X-to-Y + fix query cli + add meta api endpoints
2026-06-26 06:04:29 -07:00 · 2025-06-08 20:35:36 +02:00 · 2025-06-08 20:35:26 +02:00 · 2025-06-08 20:30:53 +02:00 · 2025-06-08 18:26:59 +02:00 · 2025-06-08 17:06:36 +02:00
58 changed files with 6006 additions and 297 deletions
@@ -1,2 +0,0 @@
-[build]
-rustflags = ["-C", "target-cpu=native"]
@@ -388,7 +388,7 @@ dependencies = [

 [[package]]
 name = "brk"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "brk_cli",
 "brk_computer",
@@ -407,7 +407,7 @@ dependencies = [

 [[package]]
 name = "brk_cli"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "bitcoincore-rpc",
 "brk_computer",
@@ -432,7 +432,7 @@ dependencies = [

 [[package]]
 name = "brk_computer"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "bitcoin",
 "bitcoincore-rpc",
@@ -453,7 +453,7 @@ dependencies = [

 [[package]]
 name = "brk_core"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "bincode",
 "bitcoin",
@@ -474,7 +474,7 @@ dependencies = [

 [[package]]
 name = "brk_exit"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "brk_logger",
 "ctrlc",
@@ -483,7 +483,7 @@ dependencies = [

 [[package]]
 name = "brk_fetcher"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "brk_core",
 "brk_logger",
@@ -496,7 +496,7 @@ dependencies = [

 [[package]]
 name = "brk_indexer"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "bitcoin",
 "bitcoincore-rpc",
@@ -514,7 +514,7 @@ dependencies = [

 [[package]]
 name = "brk_logger"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "color-eyre",
 "env_logger",
@@ -524,7 +524,7 @@ dependencies = [

 [[package]]
 name = "brk_parser"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "bitcoin",
 "bitcoincore-rpc",
@@ -539,7 +539,7 @@ dependencies = [

 [[package]]
 name = "brk_query"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "brk_computer",
 "brk_core",
@@ -557,7 +557,7 @@ dependencies = [

 [[package]]
 name = "brk_server"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "axum",
 "bitcoincore-rpc",
@@ -586,7 +586,7 @@ dependencies = [

 [[package]]
 name = "brk_state"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "bincode",
 "brk_core",
@@ -600,7 +600,7 @@ dependencies = [

 [[package]]
 name = "brk_store"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "arc-swap",
 "brk_core",
@@ -610,7 +610,7 @@ dependencies = [

 [[package]]
 name = "brk_vec"
-version = "0.0.43"
+version = "0.0.47"
 dependencies = [
 "arc-swap",
 "brk_core",
@@ -1171,9 +1171,9 @@ dependencies = [

 [[package]]
 name = "flate2"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece"
+checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
 dependencies = [
 "crc32fast",
 "libz-rs-sys",
@@ -1301,9 +1301,9 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"

 [[package]]
 name = "hashbrown"
-version = "0.15.3"
+version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3"
+checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 dependencies = [
 "allocator-api2",
 "equivalent",
@@ -1481,7 +1481,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 dependencies = [
 "equivalent",
- "hashbrown 0.15.3",
+ "hashbrown 0.15.4",
 "serde",
 ]

@@ -1887,7 +1887,7 @@ checksum = "92e50218e74886659d1d13de8e6a4ff13c7e96924ed0017bc193a1feb8001b18"
 dependencies = [
 "allocator-api2",
 "bumpalo",
- "hashbrown 0.15.3",
+ "hashbrown 0.15.4",
 "oxc_data_structures",
 "rustc-hash",
 ]
@@ -2245,7 +2245,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54acf3a685220b533e437e264e4d932cfbdc4cc7ec0cd232ed73c08d03b8a7ca"
 dependencies = [
 "fixedbitset",
- "hashbrown 0.15.3",
+ "hashbrown 0.15.4",
 "indexmap 2.9.0",
 "serde",
 ]
@@ -2378,7 +2378,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b450dad8382b1b95061d5ca1eb792081fb082adf48c678791fe917509596d5f"
 dependencies = [
 "equivalent",
- "hashbrown 0.15.3",
+ "hashbrown 0.15.4",
 ]

 [[package]]
@@ -2769,9 +2769,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"

 [[package]]
 name = "smallvec"
-version = "1.15.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"

 [[package]]
 name = "smawk"
@@ -4,7 +4,7 @@ members = ["crates/*"]
 package.description = "The Bitcoin Research Kit is a suite of tools designed to extract, compute and display data stored on a Bitcoin Core node"
 package.license = "MIT"
 package.edition = "2024"
-package.version = "0.0.43"
+package.version = "0.0.47"
 package.homepage = "https://bitcoinresearchkit.org"
 package.repository = "https://github.com/bitcoinresearchkit/brk"

@@ -31,17 +31,9 @@
  </a>
 </p>

-> **WARNING**
->
-> This project is still a work in progress and while it's much better in many ways than its previous version ([kibo v0.5](https://github.com/kibo-money/kibo)), it doesn't yet include all of those datasets. If you're interested in having everything right now, please use the latter until feature parity is achieved.
->
-> The explorer part (mempool.space/electrs) is also not viable just yet.
->
-> Stay tuned and please be patient, it's a lot of work !
-
 The Bitcoin Research Kit is a high-performance toolchain designed to parse, index, compute, serve and visualize data from a Bitcoin Core node, enabling users to gain deeper insights into the Bitcoin network.

-In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) and [electrs](https://github.com/romanz/electrs) all in one package with a particular focus on simplicity and the self-hosting experience.
+In other words it's an alternative to [Glassnode](https://glassnode.com), [mempool.space](https://mempool.space/) (soon) and [electrs](https://github.com/romanz/electrs) (soon) all in one package with a particular focus on simplicity and the self-hosting experience.

 The toolkit can be used in various ways to accommodate as many needs as possible:

@@ -1,4 +1,4 @@
-use std::fs;
+use std::{fs, thread};

 use brk_core::{dot_brk_log_path, dot_brk_path};
 use brk_query::Params as QueryArgs;
@@ -35,8 +35,12 @@ pub fn main() -> color_eyre::Result<()> {

    let cli = Cli::parse();

-    match cli.command {
-        Commands::Run(args) => run(args),
-        Commands::Query(args) => query(args),
-    }
+    thread::Builder::new()
+        .stack_size(128 * 1024 * 1024)
+        .spawn(|| match cli.command {
+            Commands::Run(args) => run(args),
+            Commands::Query(args) => query(args),
+        })?
+        .join()
+        .unwrap()
 }
@@ -19,12 +19,14 @@ pub fn query(params: QueryParams) -> color_eyre::Result<()> {
    let query = Query::build(&indexer, &computer);

    let index = Index::try_from(params.index.as_str())?;
-
    let ids = params.values.iter().map(|s| s.as_str()).collect::<Vec<_>>();
+    let from = params.from();
+    let to = params.to();
+    let format = params.format();

-    let res = query.search_and_format(index, &ids, params.from, params.to, params.format)?;
+    let res = query.search_and_format(index, &ids, from, to, format)?;

-    if params.format.is_some() {
+    if format.is_some() {
        println!("{}", res);
    } else {
        println!(
@@ -1,7 +1,7 @@
 use std::{
    fs,
    path::{Path, PathBuf},
-    thread::{self, sleep},
+    thread::sleep,
    time::Duration,
 };

@@ -49,69 +49,61 @@ pub fn run(config: RunConfig) -> color_eyre::Result<()> {
        Ok(())
    };

-    let f = move || -> color_eyre::Result<()> {
-        let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
-        computer.import_stores(&indexer)?;
-        computer.import_vecs(&indexer, config.computation())?;
+    let mut computer = Computer::new(&config.outputsdir(), config.fetcher(), format);
+    computer.import_stores(&indexer)?;
+    computer.import_vecs(&indexer, config.computation())?;

-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()?
-            .block_on(async {
-                let server = if config.serve() {
-                    let served_indexer = indexer.clone();
-                    let served_computer = computer.clone();
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()?
+        .block_on(async {
+            let server = if config.serve() {
+                let served_indexer = indexer.clone();
+                let served_computer = computer.clone();

-                    let server = Server::new(served_indexer, served_computer, config.website())?;
+                let server = Server::new(served_indexer, served_computer, config.website())?;

-                    let opt = Some(tokio::spawn(async move {
-                        server.serve().await.unwrap();
-                    }));
+                let opt = Some(tokio::spawn(async move {
+                    server.serve().await.unwrap();
+                }));

-                    sleep(Duration::from_secs(1));
+                sleep(Duration::from_secs(1));

-                    opt
-                } else {
-                    None
-                };
+                opt
+            } else {
+                None
+            };

-                if config.process() {
-                    loop {
-                        wait_for_synced_node()?;
+            if config.process() {
+                loop {
+                    wait_for_synced_node()?;

-                        let block_count = rpc.get_block_count()?;
+                    let block_count = rpc.get_block_count()?;

-                        info!("{} blocks found.", block_count + 1);
+                    info!("{} blocks found.", block_count + 1);

-                        let starting_indexes = indexer.index(&parser, rpc, &exit)?;
+                    let starting_indexes = indexer.index(&parser, rpc, &exit)?;

-                        computer.compute(&mut indexer, starting_indexes, &exit)?;
+                    computer.compute(&mut indexer, starting_indexes, &exit)?;

-                        if let Some(delay) = config.delay() {
-                            sleep(Duration::from_secs(delay))
-                        }
+                    if let Some(delay) = config.delay() {
+                        sleep(Duration::from_secs(delay))
+                    }

-                        info!("Waiting for new blocks...");
+                    info!("Waiting for new blocks...");

-                        while block_count == rpc.get_block_count()? {
-                            sleep(Duration::from_secs(1))
-                        }
+                    while block_count == rpc.get_block_count()? {
+                        sleep(Duration::from_secs(1))
                    }
                }
+            }

-                if let Some(handle) = server {
-                    handle.await.unwrap();
-                }
+            if let Some(handle) = server {
+                handle.await.unwrap();
+            }

-                Ok(())
-            })
-    };
-
-    thread::Builder::new()
-        .stack_size(128 * 1024 * 1024)
-        .spawn(f)?
-        .join()
-        .unwrap()
+            Ok(())
+        })
 }

 #[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::{fs, path::Path, thread};

 use brk_core::Version;
 use brk_exit::Exit;
@@ -44,22 +44,31 @@ impl Vecs {
    ) -> color_eyre::Result<Self> {
        fs::create_dir_all(path)?;

-        let indexes = indexes::Vecs::forced_import(
-            path,
-            version + VERSION + Version::ZERO,
-            indexer,
-            computation,
-            format,
-        )?;
+        let (indexes, fetched) = thread::scope(|s| {
+            let indexes_handle = s.spawn(|| {
+                indexes::Vecs::forced_import(
+                    path,
+                    version + VERSION + Version::ZERO,
+                    indexer,
+                    computation,
+                    format,
+                )
+                .unwrap()
+            });

-        let fetched = fetch.then(|| {
-            fetched::Vecs::forced_import(
-                path,
-                version + VERSION + Version::ZERO,
-                computation,
-                format,
-            )
-            .unwrap()
+            let fetch_handle = s.spawn(|| {
+                fetch.then(|| {
+                    fetched::Vecs::forced_import(
+                        path,
+                        version + VERSION + Version::ZERO,
+                        computation,
+                        format,
+                    )
+                    .unwrap()
+                })
+            });
+
+            (indexes_handle.join().unwrap(), fetch_handle.join().unwrap())
        });

        Ok(Self {
@@ -33,7 +33,9 @@ impl Version {
        Self(self.0.swap_bytes())
    }

-    pub fn validate(&self, path: &Path) -> Result<()> {
+    /// Ok(true) if existed and is same
+    /// Ok(false) if didn't exist
+    pub fn validate(&self, path: &Path) -> Result<bool> {
        if let Ok(prev_version) = Version::try_from(path) {
            if prev_version != *self {
                if prev_version.swap_bytes() == *self {
@@ -44,9 +46,11 @@ impl Version {
                    expected: *self,
                });
            }
-        }

-        Ok(())
+            Ok(true)
+        } else {
+            Ok(false)
+        }
    }
 }

@@ -19,7 +19,7 @@ mod vec_trees;
 pub use format::Format;
 pub use index::Index;
 pub use output::{Output, Value};
-pub use params::Params;
+pub use params::{Params, ParamsOpt};
 pub use table::Tabled;
 use vec_trees::VecTrees;

@@ -1,6 +1,8 @@
+use std::{fmt::Display, ops::Deref, str::FromStr};
+
 use clap::builder::PossibleValuesParser;
 use clap_derive::Parser;
-use serde::Deserialize;
+use serde::{Deserialize, Deserializer};
 use serde_with::{OneOrMany, formats::PreferOne, serde_as};

 use crate::{Format, Index};
@@ -17,15 +19,111 @@ pub struct Params {
    #[serde_as(as = "OneOrMany<_, PreferOne>")]
    /// Names of the values requested
    pub values: Vec<String>,
+
+    #[clap(flatten)]
+    #[serde(flatten)]
+    pub rest: ParamsOpt,
+}
+
+// The macro creates custom deserialization code.
+// You need to specify a function name and the field name of the flattened field.
+serde_with::flattened_maybe!(deserialize_rest, "rest");
+
+impl Deref for Params {
+    type Target = ParamsOpt;
+    fn deref(&self) -> &Self::Target {
+        &self.rest
+    }
+}
+
+impl From<((String, String), ParamsOpt)> for Params {
+    fn from(((index, id), rest): ((String, String), ParamsOpt)) -> Self {
+        Self {
+            index,
+            values: vec![id],
+            rest,
+        }
+    }
+}
+
+#[serde_as]
+#[derive(Debug, Deserialize, Parser)]
+pub struct ParamsOpt {
    #[clap(short, long, allow_hyphen_values = true)]
-    #[serde(alias = "f")]
+    #[serde(default, alias = "f", deserialize_with = "de_unquote_i64")]
    /// Inclusive starting index, if negative will be from the end
-    pub from: Option<i64>,
+    from: Option<i64>,
    #[clap(short, long, allow_hyphen_values = true)]
-    #[serde(default, alias = "t")]
-    /// Inclusive ending index, if negative will be from the end
-    pub to: Option<i64>,
+    #[serde(default, alias = "t", deserialize_with = "de_unquote_i64")]
+    /// Exclusive ending index, if negative will be from the end, overrides 'count'
+    to: Option<i64>,
+    #[clap(short, long, allow_hyphen_values = true)]
+    #[serde(default, alias = "c", deserialize_with = "de_unquote_usize")]
+    /// Number of values
+    count: Option<usize>,
    #[clap(short = 'F', long)]
    /// Format of the output
-    pub format: Option<Format>,
+    format: Option<Format>,
+}
+
+impl ParamsOpt {
+    pub fn from(&self) -> Option<i64> {
+        self.from
+    }
+
+    pub fn to(&self) -> Option<i64> {
+        if self.to.is_none() {
+            if let Some(c) = self.count {
+                let c = c as i64;
+                if let Some(f) = self.from {
+                    if f.is_positive() || f.abs() > c {
+                        return Some(f + c);
+                    }
+                } else {
+                    return Some(c);
+                }
+            }
+        }
+        self.to
+    }
+
+    pub fn format(&self) -> Option<Format> {
+        self.format
+    }
+}
+
+fn de_unquote_i64<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    de_unquote(deserializer)
+}
+
+fn de_unquote_usize<'de, D>(deserializer: D) -> Result<Option<usize>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    de_unquote(deserializer)
+}
+
+fn de_unquote<'de, D, F>(deserializer: D) -> Result<Option<F>, D::Error>
+where
+    D: Deserializer<'de>,
+    F: FromStr + Display,
+    <F as std::str::FromStr>::Err: Display,
+{
+    let opt: Option<String> = Option::deserialize(deserializer)?;
+    let s = match opt {
+        None => return Ok(None),
+        Some(mut s) => {
+            // strip any leading/trailing quotes
+            if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 {
+                s = s[1..s.len() - 1].to_string();
+            }
+            s
+        }
+    };
+    s.parse::<F>()
+        .map(Some)
+        .map_err(|e| serde::de::Error::custom(format!("cannot parse `{}` as type: {}", s, e)))
 }
@@ -41,22 +41,59 @@ The API uses `brk_query` and so inherites all of its features including formats.

 ### API

-#### `GET /api/vecs/indexes`
+#### [`GET /api/vecs/index-count`](https://bitcoinresearchkit.org/api/vecs/index-count)
+
+Count of all possible indexes
+
+#### [`GET /api/vecs/id-count`](https://bitcoinresearchkit.org/api/vecs/id-count)
+
+Count of all possible ids
+
+#### [`GET /api/vecs/variant-count`](https://bitcoinresearchkit.org/api/vecs/variant-count)
+
+Count of all possible variants
+
+#### [`GET /api/vecs/indexes`](https://bitcoinresearchkit.org/api/vecs/indexes)

 A list of all possible vec indexes and their accepted variants

-#### `GET /api/vecs/ids`
+#### [`GET /api/vecs/ids`](https://bitcoinresearchkit.org/api/vecs/ids)

 A list of all possible vec ids

-#### `GET /api/vecs/id-to-indexes`
+#### [`GET /api/vecs/variants`](https://bitcoinresearchkit.org/api/vecs/variants)
+
+A list of all possible variants
+
+#### [`GET /api/vecs/id-to-indexes`](https://bitcoinresearchkit.org/api/vecs/id-to-indexes)

 A list of all possible vec ids and their supported vec indexes

-#### `GET /api/vecs/index-to-ids`
+#### [`GET /api/vecs/index-to-ids`](https://bitcoinresearchkit.org/api/vecs/index-to-ids)

 A list of all possible vec indexes and their supported vec ids

+#### `GET /api/{INDEX}-to-{VALUE}`
+
+This endpoint retrieves data based on the specified vector index and id.
+
+**Parameters:**
+
+| Parameter | Type | Required | Description |
+| --- | --- | --- | --- |
+| `from` | `signed int` | No | Inclusive starting index for pagination (default is 0). |
+| `to` | `signed int` | No | Exclusive ending index for pagination (default is the total number of results). Overrides `count` |
+| `count` | `unsigned int` | No | The number of values requested |
+| `format` | `string` | No | The format of the response. Options include `json`, `csv`, `tsv`, or `md` (default is `json`). |
+
+**Examples:**
+
+```
+GET /api/date-to-close
+GET /date-to-close?from=-100
+GET /date-to-close?count=100&format=csv
+```
+
 #### `GET /api/query`

 This endpoint retrieves data based on the specified vector index and values.
@@ -67,8 +104,9 @@ This endpoint retrieves data based on the specified vector index and values.
 | --- | --- | --- | --- |
 | `index` | `VecIndex` | Yes | The vector index to query. |
 | `values` | `VecId[]` | Yes | A comma or space-separated list of vector IDs to retrieve. |
-| `from` | `unsigned int` | No | The starting index for pagination (default is 0). |
-| `to` | `unsigned int` | No | The ending index for pagination (default is the total number of results). |
+| `from` | `signed int` | No | Inclusive starting index for pagination (default is 0). |
+| `to` | `signed int` | No | Exclusive ending index for pagination (default is the total number of results). Overrides `count` |
+| `count` | `unsigned int` | No | The number of values requested |
 | `format` | `string` | No | The format of the response. Options include `json`, `csv`, `tsv`, or `md` (default is `json`). |

 **Examples:**
@@ -80,7 +118,7 @@ GET /api/query?index=week&values=ohlc,block-interval-average&from=0&to=20&format

 ### Meta

-#### `GET /version`
+#### [`GET /version`](https://bitcoinresearchkit.org/version)

 The version of the server and thus BRK.

@@ -1,18 +1,20 @@
 use std::collections::BTreeMap;

 use axum::{
-    Router,
-    extract::State,
+    Json, Router,
+    extract::{Path, Query, State},
+    http::HeaderMap,
    response::{IntoResponse, Redirect, Response},
    routing::get,
 };
+use brk_query::{Params, ParamsOpt};

 use super::AppState;

 mod explorer;
 mod query;

-pub use query::DTS;
+pub use query::Bridge;

 pub trait ApiRoutes {
    fn add_api_routes(self) -> Self;
@@ -20,24 +22,29 @@ pub trait ApiRoutes {

 impl ApiRoutes for Router<AppState> {
    fn add_api_routes(self) -> Self {
-        self.route(
-            "/api",
-            get(|| async {
-                Redirect::permanent(
-                    "https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#api",
-                )
-            }),
-        )
-        .route("/api/query", get(query::handler))
-        .route("/api/vecs/ids", get(vecids_handler))
-        .route("/api/vecs/indexes", get(vecindexes_handler))
-        .route("/api/vecs/id-to-indexes", get(vecid_to_vecindexes_handler))
-        .route("/api/vecs/index-to-ids", get(vecindex_to_vecids_handler))
+        self.route("/api/query", get(query::handler))
+            .route("/api/vecs/id-count", get(id_count_handler))
+            .route("/api/vecs/index-count", get(index_count_handler))
+            .route("/api/vecs/variant-count", get(variant_count_handler))
+            .route("/api/vecs/ids", get(ids_handler))
+            .route("/api/vecs/indexes", get(indexes_handler))
+            .route("/api/vecs/variants", get(variants_handler))
+            .route("/api/vecs/id-to-indexes", get(id_to_indexes_handler))
+            .route("/api/vecs/index-to-ids", get(index_to_ids_handler))
+            .route("/api/{variant}", get(variant_handler))
+            .route(
+                "/api",
+                get(|| async {
+                    Redirect::temporary(
+                        "https://github.com/bitcoinresearchkit/brk/tree/main/crates/brk_server#api",
+                    )
+                }),
+            )
    }
 }

-pub async fn vecids_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(
+pub async fn ids_handler(State(app_state): State<AppState>) -> Response {
+    Json(
        app_state
            .query
            .vec_trees
@@ -48,8 +55,29 @@ pub async fn vecids_handler(State(app_state): State<AppState>) -> Response {
    .into_response()
 }

-pub async fn vecindexes_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(
+pub async fn variant_count_handler(State(app_state): State<AppState>) -> Response {
+    Json(
+        app_state
+            .query
+            .vec_trees
+            .index_to_id_to_vec
+            .values()
+            .map(|tree| tree.len())
+            .sum::<usize>(),
+    )
+    .into_response()
+}
+
+pub async fn id_count_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.id_to_index_to_vec.keys().count()).into_response()
+}
+
+pub async fn index_count_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.index_to_id_to_vec.keys().count()).into_response()
+}
+
+pub async fn indexes_handler(State(app_state): State<AppState>) -> Response {
+    Json(
        app_state
            .query
            .vec_trees
@@ -61,10 +89,48 @@ pub async fn vecindexes_handler(State(app_state): State<AppState>) -> Response {
    .into_response()
 }

-pub async fn vecid_to_vecindexes_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(app_state.query.vec_trees.serialize_id_to_index_to_vec()).into_response()
+pub async fn variants_handler(State(app_state): State<AppState>) -> Response {
+    Json(
+        app_state
+            .query
+            .vec_trees
+            .index_to_id_to_vec
+            .iter()
+            .flat_map(|(index, id_to_vec)| {
+                let index_ser = index.serialize_long();
+                id_to_vec
+                    .keys()
+                    .map(|id| format!("{}-to-{}", index_ser, id))
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>(),
+    )
+    .into_response()
 }

-pub async fn vecindex_to_vecids_handler(State(app_state): State<AppState>) -> Response {
-    axum::Json(app_state.query.vec_trees.serialize_index_to_id_to_vec()).into_response()
+pub async fn id_to_indexes_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.serialize_id_to_index_to_vec()).into_response()
+}
+
+pub async fn index_to_ids_handler(State(app_state): State<AppState>) -> Response {
+    Json(app_state.query.vec_trees.serialize_index_to_id_to_vec()).into_response()
+}
+
+const TO_SEPARATOR: &str = "-to-";
+
+pub async fn variant_handler(
+    headers: HeaderMap,
+    Path(variant): Path<String>,
+    Query(params_opt): Query<ParamsOpt>,
+    state: State<AppState>,
+) -> Response {
+    let mut split = variant.split(TO_SEPARATOR);
+    let params = Params::from((
+        (
+            split.next().unwrap().to_string(),
+            split.collect::<Vec<_>>().join(TO_SEPARATOR),
+        ),
+        params_opt,
+    ));
+    query::handler(headers, Query(params), state).await
 }
@@ -2,17 +2,17 @@ use std::{fs, io, path::Path};

 use brk_query::{Index, Query};

-use crate::Website;
+use crate::{VERSION, Website};

 const SCRIPTS: &str = "scripts";

 #[allow(clippy::upper_case_acronyms)]
-pub trait DTS {
-    fn generate_dts_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
+pub trait Bridge {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
 }

-impl DTS for Query<'static> {
-    fn generate_dts_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
+impl Bridge for Query<'static> {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
        if website.is_none() {
            return Ok(());
        }
@@ -31,10 +31,16 @@ impl DTS for Query<'static> {

        let indexes = Index::all();

-        let mut contents = "//
+        let mut contents = format!(
+            "//
 // File auto-generated, any modifications will be overwritten
-//\n\n"
-            .to_string();
+//
+
+export const VERSION = \"v{}\";
+
+",
+            VERSION
+        );

        contents += &indexes
            .iter()
@@ -57,7 +63,7 @@ impl DTS for Query<'static> {

        contents += "\n\nexport function createVecIdToIndexes() {\n";

-        contents += "\n\n  return /** @type {const} */ ({\n";
+        contents += "  return /** @type {const} */ ({\n";

        self.vec_trees
            .id_to_index_to_vec
@@ -5,14 +5,18 @@ use axum::{
    response::{IntoResponse, Response},
 };
 use brk_query::{Format, Index, Output, Params};
+use brk_vec::{CollectableVec, StoredVec};
+use color_eyre::eyre::eyre;

 use crate::traits::{HeaderMapExtended, ModifiedState, ResponseExtended};

 use super::AppState;

-mod dts;
+mod bridge;

-pub use dts::*;
+pub use bridge::*;
+
+const MAX_WEIGHT: usize = 320_000;

 pub async fn handler(
    headers: HeaderMap,
@@ -33,11 +37,9 @@ pub async fn handler(
 fn req_to_response_res(
    headers: HeaderMap,
    AxumQuery(Params {
-        format,
-        from,
        index,
-        to,
        values,
+        rest,
    }): AxumQuery<Params>,
    AppState { query, .. }: AppState,
 ) -> color_eyre::Result<Response> {
@@ -48,6 +50,27 @@ fn req_to_response_res(
        &values.iter().map(|v| v.as_str()).collect::<Vec<_>>(),
    );

+    if vecs.is_empty() {
+        return Ok(Json(vec![] as Vec<usize>).into_response());
+    }
+
+    let from = rest.from();
+    let to = rest.to();
+    let format = rest.format();
+
+    let weight = vecs
+        .iter()
+        .map(|(_, v)| {
+            let len = v.len();
+            let count = StoredVec::<usize, usize>::range_count(from, to, len);
+            count * v.value_type_to_size_of()
+        })
+        .sum::<usize>();
+
+    if weight > MAX_WEIGHT {
+        return Err(eyre!("Request is too heavy, max weight is {MAX_WEIGHT}"));
+    }
+
    let mut date_modified_opt = None;

    if to.is_none() {
@@ -75,8 +98,8 @@ fn req_to_response_res(
        Output::TSV(s) => s.into_response(),
        Output::Json(v) => match v {
            brk_query::Value::Single(v) => Json(v).into_response(),
-            brk_query::Value::List(l) => Json(l).into_response(),
-            brk_query::Value::Matrix(m) => Json(m).into_response(),
+            brk_query::Value::List(v) => Json(v).into_response(),
+            brk_query::Value::Matrix(v) => Json(v).into_response(),
        },
        Output::MD(s) => s.into_response(),
    };
@@ -43,7 +43,7 @@ fn any_handler(

        let mut path = website_path.join(&path);

-        if !path.exists() {
+        if !path.exists() || path.is_dir() {
            if path.extension().is_some() {
                let mut response: Response<Body> = (
                    StatusCode::INTERNAL_SERVER_ERROR,
@@ -10,7 +10,7 @@ use std::{
    time::Duration,
 };

-use api::{ApiRoutes, DTS};
+use api::{ApiRoutes, Bridge};
 use axum::{
    Json, Router,
    body::Body,
@@ -45,10 +45,11 @@ pub struct AppState {
    websites_path: Option<PathBuf>,
 }

+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
 const DEV_PATH: &str = "../..";
 const DOWNLOADS: &str = "downloads";
 const WEBSITES: &str = "websites";
-const VERSION: &str = env!("CARGO_PKG_VERSION");

 pub struct Server(AppState);

@@ -88,7 +89,7 @@ impl Server {
                downloaded_websites_path
            };

-            query.generate_dts_file(website, websites_path.as_path())?;
+            query.generate_bridge_file(website, websites_path.as_path())?;

            Some(websites_path)
        } else {
@@ -13,6 +13,7 @@ pub trait AnyVec: Send + Sync {
    }
    fn modified_time(&self) -> Result<Duration>;
    fn index_type_to_string(&self) -> String;
+    fn value_type_to_size_of(&self) -> usize;
 }

 pub trait AnyIterableVec<I, T>: AnyVec {
@@ -27,13 +27,19 @@ where
    #[inline]
    fn i64_to_usize(i: i64, len: usize) -> usize {
        if i >= 0 {
-            i as usize
+            (i as usize).min(len)
        } else {
            let v = len as i64 + i;
            if v < 0 { 0 } else { v as usize }
        }
    }

+    fn range_count(from: Option<i64>, to: Option<i64>, len: usize) -> usize {
+        let from = from.map(|i| Self::i64_to_usize(i, len));
+        let to = to.map(|i| Self::i64_to_usize(i, len));
+        (from.unwrap_or_default()..to.unwrap_or(len)).count()
+    }
+
    #[doc(hidden)]
    fn collect_signed_range(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<T>> {
        let len = self.len();
@@ -361,6 +361,11 @@ where
    fn index_type_to_string(&self) -> String {
        I::to_string()
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 impl<I, T> Clone for CompressedVec<I, T> {
@@ -255,6 +255,11 @@ where
            ComputedVec::LazyFrom3(v) => v.modified_time(),
        }
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 pub enum ComputedVecIterator<'a, I, T, S1I, S1T, S2I, S2T, S3I, S3T> {
@@ -1298,6 +1298,11 @@ where
    fn index_type_to_string(&self) -> String {
        I::to_string()
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 impl<I, T> AnyIterableVec<I, T> for EagerVec<I, T>
@@ -127,6 +127,11 @@ where
    fn index_type_to_string(&self) -> String {
        I::to_string()
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 pub trait AnyIndexedVec: AnyVec {
@@ -146,6 +146,11 @@ where
    fn modified_time(&self) -> Result<std::time::Duration> {
        self.source.modified_time()
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 impl<I, T, S1I, S1T> AnyIterableVec<I, T> for LazyVecFrom1<I, T, S1I, S1T>
@@ -194,6 +194,11 @@ where
            .modified_time()?
            .min(self.source2.modified_time()?))
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 impl<I, T, S1I, S1T, S2I, S2T> AnyIterableVec<I, T> for LazyVecFrom2<I, T, S1I, S1T, S2I, S2T>
@@ -229,6 +229,11 @@ where
            .min(self.source2.modified_time()?)
            .min(self.source3.modified_time()?))
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 impl<I, T, S1I, S1T, S2I, S2T, S3I, S3T> AnyIterableVec<I, T>
@@ -48,8 +48,10 @@ where
        fs::create_dir_all(path)?;

        let version_path = Self::path_version_(path);
-        version.validate(version_path.as_ref())?;
-        version.write(version_path.as_ref())?;
+
+        if !version.validate(version_path.as_ref())? {
+            version.write(version_path.as_ref())?;
+        }

        let file = Self::open_file_(Self::path_vec_(path).as_path())?;
        let mmap = Arc::new(ArcSwap::new(Self::new_mmap(file)?));
@@ -195,6 +197,11 @@ where
    fn index_type_to_string(&self) -> String {
        I::to_string()
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 impl<I, T> Clone for RawVec<I, T> {
@@ -149,6 +149,11 @@ where
            StoredVec::Compressed(v) => v.name(),
        }
    }
+
+    #[inline]
+    fn value_type_to_size_of(&self) -> usize {
+        size_of::<T>()
+    }
 }

 #[derive(Debug)]
@@ -2,7 +2,7 @@
 <html lang="en">
  <head>
    <meta charset="utf-8" />
-    <title>kibo.money</title>
+    <!-- <title>kibo.money</title> -->
    <meta
      name="description"
      content="An open source Bitcoin Core data extractor and visualizer"
@@ -764,7 +764,7 @@
          text-transform: uppercase;

          & + * {
-            margin-top: 1.5rem;
+            margin-top: 1.25rem;
          }

          > details,
@@ -887,7 +887,7 @@
        bottom: 0;
        left: 0;
        right: 0;
-        z-index: 20;
+        z-index: 10;
        pointer-events: none;
      }
      .shadow-left {
@@ -901,7 +901,7 @@
        left: 0;
        top: 0;
        bottom: 0;
-        z-index: 40 !important;
+        z-index: 50;
        pointer-events: none;
      }
      .shadow-right {
@@ -915,7 +915,7 @@
        right: 0;
        top: 0;
        bottom: 0;
-        z-index: 10;
+        z-index: 30;
        pointer-events: none;
      }

@@ -1160,9 +1160,8 @@
        window.document.documentElement.dataset.display = "standalone";
      }

-      console.log(navigator);
      if ("serviceWorker" in navigator) {
-        navigator.serviceWorker.register("/scripts/service-worker.js");
+        navigator.serviceWorker.register("/service-worker.js");
      }
    </script>

@@ -1535,29 +1534,11 @@
  </head>
  <body>
    <main id="main">
-      <script>
-        // Prevent width jumping
-        const savedWidth = localStorage.getItem("bar-width");
-        if (savedWidth) {
-          const main = window.document.getElementById("main");
-          if (!main) throw "Should exist";
-          main.style.width = `${savedWidth}px`;
-        }
-      </script>
-
      <div class="shadow-top"></div>
      <div class="shadow-bottom"></div>
      <div id="resize-bar"></div>

-      <nav id="nav" hidden>
-        <h4 style="margin-top: 0.25rem">
-          <a href="/"
-            ><span style="font-weight: 500">kibo</span
-            ><span style="color: var(--gray)">.</span
-            ><span style="color: var(--orange)">money</span></a
-          >
-        </h4>
-      </nav>
+      <nav id="nav" hidden></nav>

      <search id="search" hidden>
        <header>
@@ -1625,5 +1606,15 @@
        <a id="share-anchor" href="/"></a>
      </div>
    </div>
+
+    <script>
+      // Prevent width jumping
+      const savedWidth = localStorage.getItem("bar-width");
+      if (savedWidth) {
+        const main = window.document.getElementById("main");
+        if (!main) throw "Should exist";
+        main.style.width = `${savedWidth}px`;
+      }
+    </script>
  </body>
 </html>
@@ -1,6 +1,6 @@
 // @ts-check

-/** @import {IChartApi, ISeriesApi, SeriesDefinition, SingleValueData as _SingleValueData, CandlestickData as _CandlestickData, BaselineData, SeriesType, IPaneApi, BaselineStyleOptions} from './v5.0.6-treeshaked/types' */
+/** @import {IChartApi, ISeriesApi, SeriesDefinition, SingleValueData as _SingleValueData, CandlestickData as _CandlestickData, BaselineData, SeriesType, IPaneApi, BaselineStyleOptions} from './v5.0.7-treeshaked/types' */

 /**
 * @typedef {[number, number, number, number]} OHLCTuple
@@ -22,7 +22,7 @@
 * @typedef {ChartData<_CandlestickData>} CandlestickData
 */

-export default import("./v5.0.6-treeshaked/script.js").then((lc) => {
+export default import("./v5.0.7-treeshaked/script.js").then((lc) => {
  const oklchToRGBA = createOklchToRGBA();

  /**
@@ -1,4 +1,4 @@
-import { Accessor, Setter } from "./v0.3.0-treeshaked/types/signals";
+import { Accessor, Setter } from "./v0.3.2-treeshaked/types/signals";

 export type Signal<T> = Accessor<T> & { set: Setter<T>; reset: VoidFunction };
 export type Signals = Awaited<typeof import("./wrapper.js").default>;
@@ -0,0 +1,678 @@
+// @ts-nocheck
+// src/core/error.ts
+var NotReadyError = class extends Error {};
+var EffectError = class extends Error {
+  constructor(effect, cause) {
+    super("");
+    this.cause = cause;
+  }
+};
+
+// src/core/constants.ts
+var STATE_CLEAN = 0;
+var STATE_CHECK = 1;
+var STATE_DIRTY = 2;
+var STATE_DISPOSED = 3;
+var EFFECT_PURE = 0;
+var EFFECT_RENDER = 1;
+var EFFECT_USER = 2;
+
+// src/core/scheduler.ts
+var clock = 0;
+function getClock() {
+  return clock;
+}
+function incrementClock() {
+  clock++;
+}
+var scheduled = false;
+function schedule() {
+  if (scheduled) return;
+  scheduled = true;
+  if (!globalQueue.u) queueMicrotask(flushSync);
+}
+var pureQueue = [];
+var Queue = class {
+  i = null;
+  u = false;
+  v = [[], []];
+  t = [];
+  created = clock;
+  enqueue(type, fn) {
+    pureQueue.push(fn);
+    if (type) this.v[type - 1].push(fn);
+    schedule();
+  }
+  run(type) {
+    if (type === EFFECT_PURE) {
+      pureQueue.length && runQueue(pureQueue, type);
+      pureQueue = [];
+      return;
+    } else if (this.v[type - 1].length) {
+      const effects = this.v[type - 1];
+      this.v[type - 1] = [];
+      runQueue(effects, type);
+    }
+    for (let i = 0; i < this.t.length; i++) {
+      this.t[i].run(type);
+    }
+  }
+  flush() {
+    if (this.u) return;
+    this.u = true;
+    try {
+      this.run(EFFECT_PURE);
+      incrementClock();
+      scheduled = false;
+      this.run(EFFECT_RENDER);
+      this.run(EFFECT_USER);
+    } finally {
+      this.u = false;
+    }
+  }
+  addChild(child) {
+    this.t.push(child);
+    child.i = this;
+  }
+  removeChild(child) {
+    const index = this.t.indexOf(child);
+    if (index >= 0) this.t.splice(index, 1);
+  }
+  notify(...args) {
+    if (this.i) return this.i.notify(...args);
+    return false;
+  }
+};
+var globalQueue = new Queue();
+function flushSync() {
+  while (scheduled) {
+    globalQueue.flush();
+  }
+}
+function runQueue(queue, type) {
+  for (let i = 0; i < queue.length; i++) queue[i](type);
+}
+
+// src/core/owner.ts
+var currentOwner = null;
+var defaultContext = {};
+function getOwner() {
+  return currentOwner;
+}
+function setOwner(owner) {
+  const out = currentOwner;
+  currentOwner = owner;
+  return out;
+}
+var Owner = class {
+  // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
+  // However, the children are actually added in reverse creation order
+  // See comment at the top of the file for an example of the _nextSibling traversal
+  i = null;
+  h = null;
+  l = null;
+  a = STATE_CLEAN;
+  f = null;
+  j = defaultContext;
+  g = globalQueue;
+  F = 0;
+  id = null;
+  constructor(id = null, skipAppend = false) {
+    this.id = id;
+    if (currentOwner) {
+      !skipAppend && currentOwner.append(this);
+    }
+  }
+  append(child) {
+    child.i = this;
+    child.l = this;
+    if (this.h) this.h.l = child;
+    child.h = this.h;
+    this.h = child;
+    if (this.id != null && child.id == null) child.id = this.getNextChildId();
+    if (child.j !== this.j) {
+      child.j = { ...this.j, ...child.j };
+    }
+    if (this.g) child.g = this.g;
+  }
+  dispose(self = true) {
+    if (this.a === STATE_DISPOSED) return;
+    let head = self ? this.l || this.i : this,
+      current = this.h,
+      next = null;
+    while (current && current.i === this) {
+      current.dispose(true);
+      current.o();
+      next = current.h;
+      current.h = null;
+      current = next;
+    }
+    this.F = 0;
+    if (self) this.o();
+    if (current) current.l = !self ? this : this.l;
+    if (head) head.h = current;
+  }
+  o() {
+    if (this.l) this.l.h = null;
+    this.i = null;
+    this.l = null;
+    this.j = defaultContext;
+    this.a = STATE_DISPOSED;
+    this.emptyDisposal();
+  }
+  emptyDisposal() {
+    if (!this.f) return;
+    if (Array.isArray(this.f)) {
+      for (let i = 0; i < this.f.length; i++) {
+        const callable = this.f[i];
+        callable.call(callable);
+      }
+    } else {
+      this.f.call(this.f);
+    }
+    this.f = null;
+  }
+  getNextChildId() {
+    if (this.id != null) return formatId(this.id, this.F++);
+    throw new Error("Cannot get child id from owner without an id");
+  }
+};
+function onCleanup(fn) {
+  if (!currentOwner) return fn;
+  const node = currentOwner;
+  if (!node.f) {
+    node.f = fn;
+  } else if (Array.isArray(node.f)) {
+    node.f.push(fn);
+  } else {
+    node.f = [node.f, fn];
+  }
+  return fn;
+}
+function formatId(prefix, id) {
+  const num = id.toString(36),
+    len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+}
+
+// src/core/flags.ts
+var ERROR_OFFSET = 0;
+var ERROR_BIT = 1 << ERROR_OFFSET;
+var LOADING_OFFSET = 1;
+var LOADING_BIT = 1 << LOADING_OFFSET;
+var UNINITIALIZED_OFFSET = 2;
+var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
+var DEFAULT_FLAGS = ERROR_BIT;
+
+// src/core/core.ts
+var currentObserver = null;
+var currentMask = DEFAULT_FLAGS;
+var newSources = null;
+var newSourcesIndex = 0;
+var newFlags = 0;
+var notStale = false;
+var UNCHANGED = Symbol(0);
+var Computation = class extends Owner {
+  b = null;
+  c = null;
+  e;
+  w;
+  p;
+  // Used in __DEV__ mode, hopefully removed in production
+  J;
+  // Using false is an optimization as an alternative to _equals: () => false
+  // which could enable more efficient DIRTY notification
+  A = isEqual;
+  G;
+  /** Whether the computation is an error or has ancestors that are unresolved */
+  d = 0;
+  /** Which flags raised by sources are handled, vs. being passed through. */
+  B = DEFAULT_FLAGS;
+  q = -1;
+  n = false;
+  constructor(initialValue, compute2, options) {
+    super(options?.id, compute2 === null);
+    this.p = compute2;
+    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.d = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.e = initialValue;
+    if (options?.equals !== void 0) this.A = options.equals;
+    if (options?.unobserved) this.G = options?.unobserved;
+  }
+  H() {
+    if (this.p) {
+      if (this.d & ERROR_BIT && this.q <= getClock()) update(this);
+      else this.r();
+    }
+    track(this);
+    newFlags |= this.d & ~currentMask;
+    if (this.d & ERROR_BIT) {
+      throw this.w;
+    } else {
+      return this.e;
+    }
+  }
+  /**
+   * Return the current value of this computation
+   * Automatically re-executes the surrounding computation when the value changes
+   */
+  read() {
+    return this.H();
+  }
+  /**
+   * Return the current value of this computation
+   * Automatically re-executes the surrounding computation when the value changes
+   *
+   * If the computation has any unresolved ancestors, this function waits for the value to resolve
+   * before continuing
+   */
+  wait() {
+    if (this.p && this.d & ERROR_BIT && this.q <= getClock()) {
+      update(this);
+    } else {
+      this.r();
+    }
+    track(this);
+    if ((notStale || this.d & UNINITIALIZED_BIT) && this.d & LOADING_BIT) {
+      throw new NotReadyError();
+    }
+    return this.H();
+  }
+  /** Update the computation with a new value. */
+  write(value, flags = 0, raw = false) {
+    const newValue =
+      !raw && typeof value === "function" ? value(this.e) : value;
+    const valueChanged =
+      newValue !== UNCHANGED &&
+      (!!(this.d & UNINITIALIZED_BIT) ||
+        this.d & LOADING_BIT & ~flags ||
+        this.A === false ||
+        !this.A(this.e, newValue));
+    if (valueChanged) {
+      this.e = newValue;
+      this.w = void 0;
+    }
+    const changedFlagsMask = this.d ^ flags,
+      changedFlags = changedFlagsMask & flags;
+    this.d = flags;
+    this.q = getClock() + 1;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
+        if (valueChanged) {
+          this.c[i].k(STATE_DIRTY);
+        } else if (changedFlagsMask) {
+          this.c[i].I(changedFlagsMask, changedFlags);
+        }
+      }
+    }
+    return this.e;
+  }
+  /**
+   * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
+   */
+  k(state, skipQueue) {
+    if (this.a >= state && !this.n) return;
+    this.n = !!skipQueue;
+    this.a = state;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
+        this.c[i].k(STATE_CHECK, skipQueue);
+      }
+    }
+  }
+  /**
+   * Notify the computation that one of its sources has changed flags.
+   *
+   * @param mask A bitmask for which flag(s) were changed.
+   * @param newFlags The source's new flags, masked to just the changed ones.
+   */
+  I(mask, newFlags2) {
+    if (this.a >= STATE_DIRTY) return;
+    if (mask & this.B) {
+      this.k(STATE_DIRTY);
+      return;
+    }
+    if (this.a >= STATE_CHECK) return;
+    const prevFlags = this.d & mask;
+    const deltaFlags = prevFlags ^ newFlags2;
+    if (newFlags2 === prevFlags);
+    else if (deltaFlags & prevFlags & mask) {
+      this.k(STATE_CHECK);
+    } else {
+      this.d ^= deltaFlags;
+      if (this.c) {
+        for (let i = 0; i < this.c.length; i++) {
+          this.c[i].I(mask, newFlags2);
+        }
+      }
+    }
+  }
+  C(error) {
+    this.w = error;
+    this.write(
+      UNCHANGED,
+      (this.d & ~LOADING_BIT) | ERROR_BIT | UNINITIALIZED_BIT,
+    );
+  }
+  /**
+   * This is the core part of the reactivity system, which makes sure that the values are updated
+   * before they are read. We've also adapted it to return the loading state of the computation,
+   * so that we can propagate that to the computation's observers.
+   *
+   * This function will ensure that the value and states we read from the computation are up to date
+   */
+  r() {
+    if (!this.p) {
+      return;
+    }
+    if (this.a === STATE_DISPOSED) {
+      return;
+    }
+    if (this.a === STATE_CLEAN) {
+      return;
+    }
+    let observerFlags = 0;
+    if (this.a === STATE_CHECK) {
+      for (let i = 0; i < this.b.length; i++) {
+        this.b[i].r();
+        observerFlags |= this.b[i].d;
+        if (this.a === STATE_DIRTY) {
+          break;
+        }
+      }
+    }
+    if (this.a === STATE_DIRTY) {
+      update(this);
+    } else {
+      this.write(UNCHANGED, observerFlags);
+      this.a = STATE_CLEAN;
+    }
+  }
+  /**
+   * Remove ourselves from the owner graph and the computation graph
+   */
+  o() {
+    if (this.a === STATE_DISPOSED) return;
+    if (this.b) removeSourceObservers(this, 0);
+    super.o();
+  }
+};
+function track(computation) {
+  if (currentObserver) {
+    if (
+      !newSources &&
+      currentObserver.b &&
+      currentObserver.b[newSourcesIndex] === computation
+    ) {
+      newSourcesIndex++;
+    } else if (!newSources) newSources = [computation];
+    else if (computation !== newSources[newSources.length - 1]) {
+      newSources.push(computation);
+    }
+  }
+}
+function update(node) {
+  const prevSources = newSources,
+    prevSourcesIndex = newSourcesIndex,
+    prevFlags = newFlags;
+  newSources = null;
+  newSourcesIndex = 0;
+  newFlags = 0;
+  try {
+    node.dispose(false);
+    node.emptyDisposal();
+    const result = compute(node, node.p, node);
+    node.write(result, newFlags, true);
+  } catch (error) {
+    if (error instanceof NotReadyError) {
+      node.write(
+        UNCHANGED,
+        newFlags | LOADING_BIT | (node.d & UNINITIALIZED_BIT),
+      );
+    } else {
+      node.C(error);
+    }
+  } finally {
+    if (newSources) {
+      if (node.b) removeSourceObservers(node, newSourcesIndex);
+      if (node.b && newSourcesIndex > 0) {
+        node.b.length = newSourcesIndex + newSources.length;
+        for (let i = 0; i < newSources.length; i++) {
+          node.b[newSourcesIndex + i] = newSources[i];
+        }
+      } else {
+        node.b = newSources;
+      }
+      let source;
+      for (let i = newSourcesIndex; i < node.b.length; i++) {
+        source = node.b[i];
+        if (!source.c) source.c = [node];
+        else source.c.push(node);
+      }
+    } else if (node.b && newSourcesIndex < node.b.length) {
+      removeSourceObservers(node, newSourcesIndex);
+      node.b.length = newSourcesIndex;
+    }
+    newSources = prevSources;
+    newSourcesIndex = prevSourcesIndex;
+    newFlags = prevFlags;
+    node.q = getClock() + 1;
+    node.a = STATE_CLEAN;
+  }
+}
+function removeSourceObservers(node, index) {
+  let source;
+  let swap;
+  for (let i = index; i < node.b.length; i++) {
+    source = node.b[i];
+    if (source.c) {
+      swap = source.c.indexOf(node);
+      source.c[swap] = source.c[source.c.length - 1];
+      source.c.pop();
+      if (!source.c.length) source.G?.();
+    }
+  }
+}
+function isEqual(a, b) {
+  return a === b;
+}
+function untrack(fn) {
+  if (currentObserver === null) return fn();
+  return compute(getOwner(), fn, null);
+}
+function latest(fn, fallback) {
+  const argLength = arguments.length;
+  const prevFlags = newFlags;
+  const prevNotStale = notStale;
+  notStale = false;
+  try {
+    return fn();
+  } catch (err) {
+    if (argLength > 1 && err instanceof NotReadyError) return fallback;
+    throw err;
+  } finally {
+    newFlags = prevFlags;
+    notStale = prevNotStale;
+  }
+}
+function compute(owner, fn, observer) {
+  const prevOwner = setOwner(owner),
+    prevObserver = currentObserver,
+    prevMask = currentMask,
+    prevNotStale = notStale;
+  currentObserver = observer;
+  currentMask = observer?.B ?? DEFAULT_FLAGS;
+  notStale = true;
+  try {
+    return fn(observer ? observer.e : void 0);
+  } finally {
+    setOwner(prevOwner);
+    currentObserver = prevObserver;
+    currentMask = prevMask;
+    notStale = prevNotStale;
+  }
+}
+
+// src/core/effect.ts
+var Effect = class extends Computation {
+  x;
+  y;
+  s;
+  D = false;
+  z;
+  m;
+  constructor(initialValue, compute2, effect, error, options) {
+    super(initialValue, compute2, options);
+    this.x = effect;
+    this.y = error;
+    this.z = initialValue;
+    this.m = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.m === EFFECT_RENDER) {
+      this.p = (p) =>
+        getClock() > this.g.created && !(this.d & ERROR_BIT)
+          ? latest(() => compute2(p))
+          : compute2(p);
+    }
+    this.r();
+    !options?.defer &&
+      (this.m === EFFECT_USER
+        ? this.g.enqueue(this.m, this.E.bind(this))
+        : this.E(this.m));
+  }
+  write(value, flags = 0) {
+    if (this.a == STATE_DIRTY) {
+      this.d;
+      this.d = flags;
+      if (this.m === EFFECT_RENDER) {
+        this.g.notify(this, LOADING_BIT | ERROR_BIT, flags);
+      }
+    }
+    if (value === UNCHANGED) return this.e;
+    this.e = value;
+    this.D = true;
+    return value;
+  }
+  k(state, skipQueue) {
+    if (this.a >= state || skipQueue) return;
+    if (this.a === STATE_CLEAN) this.g.enqueue(this.m, this.E.bind(this));
+    this.a = state;
+  }
+  C(error) {
+    this.w = error;
+    this.s?.();
+    this.g.notify(this, LOADING_BIT, 0);
+    this.d = ERROR_BIT;
+    if (this.m === EFFECT_USER) {
+      try {
+        return this.y
+          ? (this.s = this.y(error))
+          : console.error(new EffectError(this.x, error));
+      } catch (e) {
+        error = e;
+      }
+    }
+    if (!this.g.notify(this, ERROR_BIT, ERROR_BIT)) throw error;
+  }
+  o() {
+    if (this.a === STATE_DISPOSED) return;
+    this.x = void 0;
+    this.z = void 0;
+    this.y = void 0;
+    this.s?.();
+    this.s = void 0;
+    super.o();
+  }
+  E(type) {
+    if (type) {
+      if (this.D && this.a !== STATE_DISPOSED) {
+        this.s?.();
+        try {
+          this.s = this.x(this.e, this.z);
+        } catch (e) {
+          if (!this.g.notify(this, ERROR_BIT, ERROR_BIT)) throw e;
+        } finally {
+          this.z = this.e;
+          this.D = false;
+        }
+      }
+    } else this.a !== STATE_CLEAN && runTop(this);
+  }
+};
+function runTop(node) {
+  const ancestors = [];
+  for (let current = node; current !== null; current = current.i) {
+    if (current.a !== STATE_CLEAN) {
+      ancestors.push(current);
+    }
+  }
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    if (ancestors[i].a !== STATE_DISPOSED) ancestors[i].r();
+  }
+}
+
+// src/signals.ts
+function createSignal(first, second, third) {
+  if (typeof first === "function") {
+    const memo = createMemo((p) => {
+      const node2 = new Computation(
+        first(p ? untrack(p[0]) : second),
+        null,
+        third,
+      );
+      return [node2.read.bind(node2), node2.write.bind(node2)];
+    });
+    return [() => memo()[0](), (value) => memo()[1](value)];
+  }
+  const o = getOwner();
+  const needsId = o?.id != null;
+  const node = new Computation(
+    first,
+    null,
+    needsId ? { id: o.getNextChildId(), ...second } : second,
+  );
+  return [node.read.bind(node), node.write.bind(node)];
+}
+function createMemo(compute2, value, options) {
+  let node = new Computation(value, compute2, options);
+  let resolvedValue;
+  return () => {
+    if (node) {
+      if (node.a === STATE_DISPOSED) {
+        node = void 0;
+        return resolvedValue;
+      }
+      resolvedValue = node.wait();
+      if (!node.b?.length && node.h?.i !== node) {
+        node.dispose();
+        node = void 0;
+      }
+    }
+    return resolvedValue;
+  };
+}
+function createEffect(compute2, effect, error, value, options) {
+  void new Effect(value, compute2, effect, error, options);
+}
+function createRoot(init, options) {
+  const owner = new Owner(options?.id);
+  return compute(
+    owner,
+    !init.length ? init : () => init(() => owner.dispose()),
+    null,
+  );
+}
+function runWithOwner(owner, run) {
+  return compute(owner, run, null);
+}
+
+export {
+  Owner,
+  createEffect,
+  createMemo,
+  createRoot,
+  createSignal,
+  getOwner,
+  onCleanup,
+  runWithOwner,
+  untrack,
+};
@@ -0,0 +1,21 @@
+import { Computation, Queue } from "./core/index.js";
+import type { Effect } from "./core/index.js";
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _nodes: Set<Effect>;
+    _disabled: Computation<boolean>;
+    constructor(type: number);
+    run(type: number): void;
+    notify(node: Effect, type: number, flags: number): boolean;
+}
+export declare enum BoundaryMode {
+    VISIBLE = "visible",
+    HIDDEN = "hidden"
+}
+export declare function createBoundary<T>(fn: () => T, condition: () => BoundaryMode): () => T | undefined;
+export declare function createSuspense(fn: () => any, fallback: () => any): () => any;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => any;
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;
@@ -0,0 +1,14 @@
+/**
+ * See https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph
+ * State clean corresponds to a node where all the sources are fully up to date
+ * State check corresponds to a node where some sources (including grandparents) may have changed
+ * State dirty corresponds to a node where the direct parents of a node has changed
+ */
+export declare const STATE_CLEAN = 0;
+export declare const STATE_CHECK = 1;
+export declare const STATE_DIRTY = 2;
+export declare const STATE_DISPOSED = 3;
+export declare const EFFECT_PURE = 0;
+export declare const EFFECT_RENDER = 1;
+export declare const EFFECT_USER = 2;
+export declare const SUPPORTS_PROXY: boolean;
@@ -0,0 +1,155 @@
+/**
+ * Nodes for constructing a graph of reactive values and reactive computations.
+ *
+ * - The graph is acyclic.
+ * - The user inputs new values into the graph by calling .write() on one more computation nodes.
+ * - The user retrieves computed results from the graph by calling .read() on one or more computation nodes.
+ * - The library is responsible for running any necessary computations so that .read() is up to date
+ *   with all prior .write() calls anywhere in the graph.
+ * - We call the input nodes 'roots' and the output nodes 'leaves' of the graph here.
+ * - Changes flow from roots to leaves. It would be effective but inefficient to immediately
+ *   propagate all changes from a root through the graph to descendant leaves. Instead, we defer
+ *   change most change propagation computation until a leaf is accessed. This allows us to
+ *   coalesce computations and skip altogether recalculating unused sections of the graph.
+ * - Each computation node tracks its sources and its observers (observers are other
+ *   elements that have this node as a source). Source and observer links are updated automatically
+ *   as observer computations re-evaluate and call get() on their sources.
+ * - Each node stores a cache state (clean/check/dirty) to support the change propagation algorithm:
+ *
+ * In general, execution proceeds in three passes:
+ *
+ *  1. write() propagates changes down the graph to the leaves
+ *     direct children are marked as dirty and their deeper descendants marked as check
+ *     (no computations are evaluated)
+ *  2. read() requests that parent nodes updateIfNecessary(), which proceeds recursively up the tree
+ *     to decide whether the node is clean (parents unchanged) or dirty (parents changed)
+ *  3. updateIfNecessary() evaluates the computation if the node is dirty (the computations are
+ *     executed in root to leaf order)
+ */
+import { type Flags } from "./flags.js";
+import { Owner } from "./owner.js";
+export interface SignalOptions<T> {
+    id?: string;
+    name?: string;
+    equals?: ((prev: T, next: T) => boolean) | false;
+    unobserved?: () => void;
+}
+interface SourceType {
+    _observers: ObserverType[] | null;
+    _unobserved?: () => void;
+    _updateIfNecessary: () => void;
+    _stateFlags: Flags;
+    _time: number;
+}
+interface ObserverType {
+    _sources: SourceType[] | null;
+    _notify: (state: number, skipQueue?: boolean) => void;
+    _handlerMask: Flags;
+    _notifyFlags: (mask: Flags, newFlags: Flags) => void;
+    _time: number;
+}
+/**
+ * Returns the current observer.
+ */
+export declare function getObserver(): Computation | null;
+export declare const UNCHANGED: unique symbol;
+export type UNCHANGED = typeof UNCHANGED;
+export declare class Computation<T = any> extends Owner implements SourceType, ObserverType {
+    _sources: SourceType[] | null;
+    _observers: ObserverType[] | null;
+    _value: T | undefined;
+    _error: unknown;
+    _compute: null | ((p?: T) => T);
+    _name: string | undefined;
+    _equals: false | ((a: T, b: T) => boolean);
+    _unobserved: (() => void) | undefined;
+    /** Whether the computation is an error or has ancestors that are unresolved */
+    _stateFlags: number;
+    /** Which flags raised by sources are handled, vs. being passed through. */
+    _handlerMask: number;
+    _time: number;
+    _forceNotify: boolean;
+    constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
+    _read(): T;
+    /**
+     * Return the current value of this computation
+     * Automatically re-executes the surrounding computation when the value changes
+     */
+    read(): T;
+    /**
+     * Return the current value of this computation
+     * Automatically re-executes the surrounding computation when the value changes
+     *
+     * If the computation has any unresolved ancestors, this function waits for the value to resolve
+     * before continuing
+     */
+    wait(): T;
+    /** Update the computation with a new value. */
+    write(value: T | ((currentValue: T) => T) | UNCHANGED, flags?: number, raw?: boolean): T;
+    /**
+     * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
+     */
+    _notify(state: number, skipQueue?: boolean): void;
+    /**
+     * Notify the computation that one of its sources has changed flags.
+     *
+     * @param mask A bitmask for which flag(s) were changed.
+     * @param newFlags The source's new flags, masked to just the changed ones.
+     */
+    _notifyFlags(mask: Flags, newFlags: Flags): void;
+    _setError(error: unknown): void;
+    /**
+     * This is the core part of the reactivity system, which makes sure that the values are updated
+     * before they are read. We've also adapted it to return the loading state of the computation,
+     * so that we can propagate that to the computation's observers.
+     *
+     * This function will ensure that the value and states we read from the computation are up to date
+     */
+    _updateIfNecessary(): void;
+    /**
+     * Remove ourselves from the owner graph and the computation graph
+     */
+    _disposeNode(): void;
+}
+/**
+ * Reruns a computation's _compute function, producing a new value and keeping track of dependencies.
+ *
+ * It handles the updating of sources and observers, disposal of previous executions,
+ * and error handling if the _compute function throws. It also sets the node as loading
+ * if it reads any parents that are currently loading.
+ */
+export declare function update<T>(node: Computation<T>): void;
+export declare function isEqual<T>(a: T, b: T): boolean;
+/**
+ * Returns the current value stored inside the given compute function without triggering any
+ * dependencies. Use `untrack` if you want to also disable owner tracking.
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Returns true if the given functinon contains signals that have been updated since the last time
+ * the parent computation was run.
+ */
+export declare function hasUpdated(fn: () => any): boolean;
+/**
+ * Returns an accessor that is true if the given function contains async signals that are out of date.
+ */
+export declare function isPending(fn: () => any): boolean;
+export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
+/**
+ * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
+ */
+export declare function latest<T>(fn: () => T): T;
+export declare function latest<T, U>(fn: () => T, fallback: U): T | U;
+/**
+ * Runs the given function in the given observer.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ */
+export declare function runWithObserver<T>(observer: Computation, run: () => T): T | undefined;
+/**
+ * A convenient wrapper that calls `compute` with the `owner` and `observer` and is guaranteed
+ * to reset the global context after the computation is finished even if an error is thrown.
+ */
+export declare function compute<T>(owner: Owner | null, fn: (val: T) => T, observer: Computation<T>): T;
+export declare function compute<T>(owner: Owner | null, fn: (val: undefined) => T, observer: null): T;
+export {};
@@ -0,0 +1,34 @@
+import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { Computation, type SignalOptions } from "./core.js";
+/**
+ * Effects are the leaf nodes of our reactive graph. When their sources change, they are
+ * automatically added to the queue of effects to re-execute, which will cause them to fetch their
+ * sources and recompute
+ */
+export declare class Effect<T = any> extends Computation<T> {
+    _effect: (val: T, prev: T | undefined) => void | (() => void);
+    _onerror: ((err: unknown) => void | (() => void)) | undefined;
+    _cleanup: (() => void) | undefined;
+    _modified: boolean;
+    _prevValue: T | undefined;
+    _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
+    constructor(initialValue: T, compute: (val?: T) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown) => void | (() => void), options?: SignalOptions<T> & {
+        render?: boolean;
+        defer?: boolean;
+    });
+    write(value: T, flags?: number): T;
+    _notify(state: number, skipQueue?: boolean): void;
+    _setError(error: unknown): void;
+    _disposeNode(): void;
+    _runEffect(type: number): void;
+}
+export declare class EagerComputation<T = any> extends Computation<T> {
+    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
+        defer?: boolean;
+    });
+    _notify(state: number, skipQueue?: boolean): void;
+}
+export declare class ProjectionComputation extends Computation {
+    constructor(compute: () => void);
+    _notify(state: number, skipQueue?: boolean): void;
+}
@@ -0,0 +1,11 @@
+export declare class NotReadyError extends Error {
+}
+export declare class NoOwnerError extends Error {
+    constructor();
+}
+export declare class ContextNotFoundError extends Error {
+    constructor();
+}
+export declare class EffectError extends Error {
+    constructor(effect: Function, cause: unknown);
+}
@@ -0,0 +1,11 @@
+export type Flags = number;
+export declare const ERROR_OFFSET = 0;
+export declare const ERROR_BIT: number;
+export declare const ERROR: unique symbol;
+export declare const LOADING_OFFSET = 1;
+export declare const LOADING_BIT: number;
+export declare const LOADING: unique symbol;
+export declare const UNINITIALIZED_OFFSET = 2;
+export declare const UNINITIALIZED_BIT: number;
+export declare const UNINITIALIZED: unique symbol;
+export declare const DEFAULT_FLAGS: number;
@@ -0,0 +1,7 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
+export { Owner, createContext, getContext, setContext, hasContext, getOwner, onCleanup, type Context, type ContextRecord, type Disposable } from "./owner.js";
+export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
+export { Effect, EagerComputation } from "./effect.js";
+export { flushSync, Queue, incrementClock, getClock, type IQueue } from "./scheduler.js";
+export * from "./constants.js";
+export * from "./flags.js";
@@ -0,0 +1,95 @@
+/**
+ * Owner tracking is used to enable nested tracking scopes with automatic cleanup.
+ * We also use owners to also keep track of which error handling context we are in.
+ *
+ * If you write the following
+ *
+ *   const a = createOwner(() => {
+ *     const b = createOwner(() => {});
+ *
+ *     const c = createOwner(() => {
+ *       const d = createOwner(() => {});
+ *     });
+ *
+ *     const e = createOwner(() => {});
+ *   });
+ *
+ * The owner tree will look like this:
+ *
+ *    a
+ *   /|\
+ *  b-c-e
+ *    |
+ *    d
+ *
+ * Following the _nextSibling pointers of each owner will first give you its children, and then its siblings (in reverse).
+ * a -> e -> c -> d -> b
+ *
+ * Note that the owner tree is largely orthogonal to the reactivity tree, and is much closer to the component tree.
+ */
+import { type IQueue } from "./scheduler.js";
+export type ContextRecord = Record<string | symbol, unknown>;
+export interface Disposable {
+    (): void;
+}
+/**
+ * Returns the currently executing parent owner.
+ */
+export declare function getOwner(): Owner | null;
+export declare function setOwner(owner: Owner | null): Owner | null;
+export declare class Owner {
+    _parent: Owner | null;
+    _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
+    _state: number;
+    _disposal: Disposable | Disposable[] | null;
+    _context: ContextRecord;
+    _queue: IQueue;
+    _childCount: number;
+    id: string | null;
+    constructor(id?: string | null, skipAppend?: boolean);
+    append(child: Owner): void;
+    dispose(this: Owner, self?: boolean): void;
+    _disposeNode(): void;
+    emptyDisposal(): void;
+    getNextChildId(): string;
+}
+export interface Context<T> {
+    readonly id: symbol;
+    readonly defaultValue: T | undefined;
+}
+/**
+ * Context provides a form of dependency injection. It is used to save from needing to pass
+ * data as props through intermediate components. This function creates a new context object
+ * that can be used with `getContext` and `setContext`.
+ *
+ * A default value can be provided here which will be used when a specific value is not provided
+ * via a `setContext` call.
+ */
+export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
+/**
+ * Attempts to get a context value for the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ * @throws `ContextNotFoundError` if a context value has not been set yet.
+ */
+export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
+/**
+ * Attempts to set a context value on the parent scope with the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ */
+export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;
+/**
+ * Whether the given context is currently defined.
+ */
+export declare function hasContext(context: Context<any>, owner?: Owner | null): boolean;
+/**
+ * Runs an effect once before the reactive scope is disposed
+ * @param fn an effect that should run only once on cleanup
+ *
+ * @returns the same {@link fn} function that was passed in
+ *
+ * @description https://docs.solidjs.com/reference/lifecycle/on-cleanup
+ */
+export declare function onCleanup(fn: Disposable): Disposable;
@@ -0,0 +1,33 @@
+export declare function getClock(): number;
+export declare function incrementClock(): void;
+type QueueCallback = (type: number) => void;
+export interface IQueue {
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): boolean | void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    created: number;
+    notify(...args: any[]): boolean;
+    _parent: IQueue | null;
+}
+export declare class Queue implements IQueue {
+    _parent: IQueue | null;
+    _running: boolean;
+    _queues: [QueueCallback[], QueueCallback[]];
+    _children: IQueue[];
+    created: number;
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    notify(...args: any[]): boolean;
+}
+export declare const globalQueue: Queue;
+/**
+ * By default, changes are batched on the microtask queue which is an async process. You can flush
+ * the queue synchronously to get the latest updates by calling `flushSync()`.
+ */
+export declare function flushSync(): void;
+export {};
@@ -0,0 +1,3 @@
+export { Owner, getOwner, onCleanup, untrack } from "./core/index.js";
+export type { SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
+export * from "./signals.js";
@@ -0,0 +1,22 @@
+import type { Accessor } from "./signals.js";
+export type Maybe<T> = T | void | null | undefined | false;
+/**
+ * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ *
+ * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ */
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: boolean | ((item: Item) => any);
+    fallback?: Accessor<any>;
+}): Accessor<MappedItem[]>;
+/**
+ * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */
+export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
+    from?: Accessor<number | undefined>;
+    fallback?: Accessor<any>;
+}): Accessor<any[]>;
@@ -0,0 +1,138 @@
+import type { SignalOptions } from "./core/index.js";
+import { Owner } from "./core/index.js";
+export type Accessor<T> = () => T;
+export type Setter<in out T> = {
+    <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
+    <U extends T>(value: (prev: T) => U): U;
+    <U extends T>(value: Exclude<U, Function>): U;
+    <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
+};
+export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
+export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
+export interface EffectOptions {
+    name?: string;
+    defer?: boolean;
+}
+export interface MemoOptions<T> {
+    name?: string;
+    equals?: false | ((prev: T, next: T) => boolean);
+}
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+/**
+ * Creates a simple reactive state with a getter and setter
+ * ```typescript
+ * const [state: Accessor<T>, setState: Setter<T>] = createSignal<T>(
+ *  value: T,
+ *  options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * )
+ * ```
+ * @param value initial value of the state; if empty, the state's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
+ * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
+ *
+ * @returns ```typescript
+ * [state: Accessor<T>, setState: Setter<T>]
+ * ```
+ * * the Accessor is a function that returns the current value and registers each call to the reactive root
+ * * the Setter is a function that allows directly setting or mutating the value:
+ * ```typescript
+ * const [count, setCount] = createSignal(0);
+ * setCount(count => count + 1);
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
+ */
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Creates a readonly derived reactive memoized signal
+ * ```typescript
+ * export function createMemo<T>(
+ *   compute: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
+ */
+export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+/**
+ * Creates a readonly derived async reactive memoized signal
+ * ```typescript
+ * export function createAsync<T>(
+ *   compute: (v: T) => Promise<T> | T,
+ *   value?: T,
+ *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-async
+ */
+/**
+ * Creates a reactive effect that runs after the render phase
+ * ```typescript
+ * export function createEffect<T>(
+ *   compute: (prev: T) => T,
+ *   effect: (v: T, prev: T) => (() => void) | void,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param effect a function that receives the new value and is used to perform side effects, return a cleanup function to run on disposal
+ * @param error an optional function that receives an error if thrown during the computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ */
+export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>, error?: (err: unknown) => void): void;
+export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, error: ((err: unknown) => void) | undefined, value: Init, options?: EffectOptions): void;
+/**
+ * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
+ * ```typescript
+ * export function createRenderEffect<T>(
+ *   compute: (prev: T) => T,
+ *   effect: (v: T, prev: T) => (() => void) | void,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param effect a function that receives the new value and is used to perform side effects
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ */
+/**
+ * Creates a new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id: string;
+}): T;
+/**
+ * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
+ * This method untracks the current scope.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ */
+export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T;
+/**
+ * Returns a promise of the resolved value of a reactive expression
+ * @param fn a reactive expression to resolve
+ */
@@ -0,0 +1,6 @@
+export type { Store, StoreSetter, StoreNode, NotWrappable, SolidStore } from "./store.js";
+export type { Merge, Omit } from "./utils.js";
+export { unwrap, isWrappable, createStore, deep, $RAW, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { createProjection } from "./projection.js";
+export { reconcile } from "./reconcile.js";
+export { merge, omit } from "./utils.js";
@@ -0,0 +1,8 @@
+import { type Store, type StoreSetter } from "./store.js";
+/**
+ * Creates a mutable derived value
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
+ */
+export declare function createProjection<T extends Object>(fn: (draft: T) => void, initialValue?: T): Store<T>;
+export declare function wrapProjection<T>(fn: (draft: T) => void, store: Store<T>, setStore: StoreSetter<T>): [Store<T>, StoreSetter<T>];
@@ -0,0 +1 @@
+export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => T;
@@ -0,0 +1,35 @@
+import { Computation } from "../core/index.js";
+export type Store<T> = Readonly<T>;
+export type StoreSetter<T> = (fn: (state: T) => void) => void;
+type DataNode = Computation<any>;
+type DataNodes = Record<PropertyKey, DataNode>;
+declare const $RAW: unique symbol, $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol;
+export declare const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
+export { $PROXY, $TRACK, $RAW, $TARGET };
+export type StoreNode = {
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+};
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export declare function wrap<T extends Record<PropertyKey, any>>(value: T): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+/**
+ * Returns the underlying data in the store without a proxy.
+ * @param item store proxy object
+ * @example
+ * ```js
+ * const initial = {z...};
+ * const [state, setState] = createStore(initial);
+ * initial === state; // => false
+ * initial === unwrap(state); // => true
+ * ```
+ */
+export declare function unwrap<T>(item: T, deep?: boolean, set?: Set<unknown>): T;
+export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void, store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function deep<T extends object>(store: Store<T>): Store<any>;
@@ -0,0 +1,29 @@
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _Merge<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export type Omit<T, K extends readonly (keyof T)[]> = {
+    [P in keyof T as Exclude<P, K[number]>]: T[P];
+};
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export {};
@@ -1,13 +1,13 @@
 // @ts-check

 /**
- * @import { SignalOptions } from "./v0.3.0-treeshaked/types/core/core"
- * @import { getOwner as GetOwner, onCleanup as OnCleanup, Owner } from "./v0.3.0-treeshaked/types/core/owner"
- * @import { createSignal as CreateSignal, createEffect as CreateEffect, Accessor, Setter, createMemo as CreateMemo, createRoot as CreateRoot, runWithOwner as RunWithOwner } from "./v0.3.0-treeshaked/types/signals";
+ * @import { SignalOptions } from "./v0.3.2-treeshaked/types/core/core"
+ * @import { getOwner as GetOwner, onCleanup as OnCleanup } from "./v0.3.2-treeshaked/types/core/owner"
+ * @import { createSignal as CreateSignal, createEffect as CreateEffect, createMemo as CreateMemo, createRoot as CreateRoot, runWithOwner as RunWithOwner } from "./v0.3.2-treeshaked/types/signals";
 * @import { Signal } from "./types";
 */

-const importSignals = import("./v0.3.0-treeshaked/script.js").then(
+const importSignals = import("./v0.3.2-treeshaked/script.js").then(
  (_signals) => {
    const signals = {
      createSolidSignal: /** @type {typeof CreateSignal} */ (
@@ -4,11 +4,11 @@
 * @import { Option, PartialChartOption, ChartOption, AnyPartialOption, ProcessedOptionAddons, OptionsTree, SimulationOption, AnySeriesBlueprint, ChartableIndex,CreatePriceLineOptions, CreatePriceLine } from "./options"
 * @import {Valued,  SingleValueData, CandlestickData, ChartData, OHLCTuple} from "../packages/lightweight-charts/wrapper"
 * @import * as _ from "../packages/ufuzzy/v1.0.14/types"
- * @import { createChart as CreateClassicChart, LineStyleOptions, DeepPartial, ChartOptions, IChartApi, IHorzScaleBehavior, WhitespaceData, ISeriesApi, Time, LineData, LogicalRange, BaselineStyleOptions, SeriesOptionsCommon, BaselineData, CandlestickStyleOptions } from "../packages/lightweight-charts/v5.0.6-treeshaked/types"
- * @import { SignalOptions } from "../packages/solid-signals/v0.3.0-treeshaked/types/core/core"
+ * @import { createChart as CreateClassicChart, LineStyleOptions, DeepPartial, ChartOptions, IChartApi, IHorzScaleBehavior, WhitespaceData, ISeriesApi, Time, LineData, LogicalRange, BaselineStyleOptions, SeriesOptionsCommon, BaselineData, CandlestickStyleOptions } from "../packages/lightweight-charts/v5.0.7-treeshaked/types"
+ * @import { SignalOptions } from "../packages/solid-signals/v0.3.2-treeshaked/types/core/core"
 * @import {Signal, Signals} from "../packages/solid-signals/types";
- * @import { getOwner as GetOwner, onCleanup as OnCleanup, Owner } from "../packages/solid-signals/v0.3.0-treeshaked/types/core/owner"
- * @import { createEffect as CreateEffect, Accessor, Setter, createMemo as CreateMemo } from "../packages/solid-signals/v0.3.0-treeshaked/types/signals";
+ * @import { getOwner as GetOwner, onCleanup as OnCleanup, Owner } from "../packages/solid-signals/v0.3.2-treeshaked/types/core/owner"
+ * @import { createEffect as CreateEffect, Accessor, Setter, createMemo as CreateMemo } from "../packages/solid-signals/v0.3.2-treeshaked/types/signals";
 * @import {DateIndex, DecadeIndex, DifficultyEpoch, Index, HalvingEpoch, Height, MonthIndex, P2PK33Index, P2PK65Index, P2PKHIndex, P2SHIndex, P2MSIndex, P2AIndex, P2TRIndex, P2WPKHIndex, P2WSHIndex, TxIndex, InputIndex, OutputIndex, VecId, WeekIndex, YearIndex, VecIdToIndexes, QuarterIndex, EmptyOutputIndex, OpReturnIndex, UnknownOutputIndex} from "./vecid-to-indexes"
 */

@@ -2062,7 +2062,7 @@ function initWebSockets(signals, utils) {

        window.document.title = `${latest.close.toLocaleString(
          "en-us",
-        )} | kibo.money`;
+        )} | ${window.location.host}`;
      }
    });
  }
@@ -2189,8 +2189,10 @@ function main() {
  createKeyDownEventListener();

  packages.signals().then((signals) =>
-    vecidToIndexesPromise.then(({ createVecIdToIndexes }) =>
+    vecidToIndexesPromise.then(({ createVecIdToIndexes, VERSION }) =>
      optionsPromise.then(async ({ initOptions }) => {
+        console.log(`VERSION = ${VERSION}`);
+
        const vecIdToIndexes = createVecIdToIndexes();

        if (env.localhost) {
@@ -2795,10 +2795,6 @@ function createPartialOptions(colors) {
    {
      name: "Social",
      tree: [
-        {
-          name: "Github",
-          url: () => "https://github.com/bitcoinresearchkit/brk",
-        },
        {
          name: "Nostr",
          url: () =>
@@ -2867,6 +2863,10 @@ function createPartialOptions(colors) {
          url: () =>
            "lightning:lnurl1dp68gurn8ghj7ampd3kx2ar0veekzar0wd5xjtnrdakj7tnhv4kxctttdehhwm30d3h82unvwqhkxmmww3jkuar8d35kgetj8yuq363hv4",
        },
+        {
+          name: "Geyser",
+          url: () => "https://geyser.fund/project/brk",
+        },
      ],
    },
    {
@@ -1,76 +0,0 @@
-const version = "v1";
-
-/** @type {ServiceWorkerGlobalScope} */
-const sw = /** @type {any} */ (self);
-
-sw.addEventListener("install", (_event) => {
-  console.log("sw: install");
-  sw.skipWaiting();
-});
-
-sw.addEventListener("activate", (event) => {
-  console.log("sw: active");
-  event.waitUntil(sw.clients.claim());
-});
-
-sw.addEventListener("fetch", (event) => {
-  let request = event.request;
-  const method = request.method;
-  let url = request.url;
-
-  const { pathname, origin } = new URL(url);
-
-  const slashMatches = url.match(/\//g);
-  const dotMatches = pathname.split("/").at(-1)?.match(/./g);
-  const endsWithDotHtml = pathname.endsWith(".html");
-  const slashApiSlashMatches = url.match(/\/api\//g);
-
-  if (
-    slashMatches &&
-    slashMatches.length <= 3 &&
-    !slashApiSlashMatches &&
-    (!dotMatches || endsWithDotHtml)
-  ) {
-    url = `${origin}/`;
-  }
-  request = new Request(url, request.mode !== "navigate" ? request : undefined);
-
-  console.log(request);
-
-  console.log(`service-worker: fetch ${url}`);
-
-  event.respondWith(
-    caches.match(request).then(async (cachedResponse) => {
-      return fetch(request)
-        .then((response) => {
-          const { status, type } = response;
-
-          if (method !== "GET" || slashApiSlashMatches) {
-            // API calls are cached in script.js
-            return response;
-          } else if ((status === 200 || status === 304) && type === "basic") {
-            if (status === 200) {
-              const clonedResponse = response.clone();
-              caches.open(version).then((cache) => {
-                cache.put(request, clonedResponse);
-              });
-            }
-            return response;
-          } else {
-            return cachedResponse || response;
-          }
-        })
-        .catch(() => {
-          console.log("service-worker: offline");
-
-          return (
-            cachedResponse ||
-            new Response("Offline", {
-              status: 503,
-              statusText: "Service Unavailable",
-            })
-          );
-        });
-    }),
-  );
-});
@@ -2,6 +2,8 @@
 // File auto-generated, any modifications will be overwritten
 //

+export const VERSION = "v0.0.46";
+
 /** @typedef {0} DateIndex */
 /** @typedef {1} DecadeIndex */
 /** @typedef {2} DifficultyEpoch */
@@ -30,8 +32,6 @@
 /** @typedef {DateIndex | DecadeIndex | DifficultyEpoch | EmptyOutputIndex | HalvingEpoch | Height | InputIndex | MonthIndex | OpReturnIndex | OutputIndex | P2AIndex | P2MSIndex | P2PK33Index | P2PK65Index | P2PKHIndex | P2SHIndex | P2TRIndex | P2WPKHIndex | P2WSHIndex | QuarterIndex | TxIndex | UnknownOutputIndex | WeekIndex | YearIndex} Index */

 export function createVecIdToIndexes() {
-
-
  return /** @type {const} */ ({
    "0": [0, 1, 2, 5, 7, 19, 22, 23],
    "0sats-adjusted-spent-output-profit-ratio": [0],
@@ -0,0 +1,81 @@
+const CACHE_NAME = "v1";
+
+/** @type {ServiceWorkerGlobalScope} */
+const sw = /** @type {any} */ (self);
+
+sw.addEventListener("install", (event) => {
+  console.log("sw: install");
+  event.waitUntil(sw.skipWaiting());
+});
+
+sw.addEventListener("activate", (event) => {
+  console.log("sw: active");
+  event.waitUntil(sw.clients.claim());
+  event.waitUntil(caches.delete(CACHE_NAME));
+});
+
+async function indexHTMLOrOffline() {
+  return caches.match("/index.html").then((cached) => {
+    if (cached) return cached;
+    return new Response("Offline and no cached version", {
+      status: 503,
+      statusText: "Service Unavailable",
+      headers: { "Content-Type": "text/plain" },
+    });
+  });
+}
+
+sw.addEventListener("fetch", (event) => {
+  const req = event.request;
+  const url = new URL(req.url);
+
+  // 1) Bypass API calls & non-GETs
+  if (req.method !== "GET" || url.pathname.startsWith("/api")) {
+    return; // let the browser handle it
+  }
+
+  // 2) NAVIGATION: network‐first on your shell
+  if (req.mode === "navigate") {
+    event.respondWith(
+      // Always fetch index.html
+      fetch("/index.html")
+        .then((response) => {
+          // If we got a valid 2xx back, cache it (optional) and return it
+          if (response.ok || response.status === 304) {
+            if (response.ok) {
+              const clone = response.clone();
+              caches
+                .open(CACHE_NAME)
+                .then((cache) => cache.put("/index.html", clone));
+            }
+            return response;
+          }
+          throw new Error("Non-2xx on shell");
+        })
+        // On any failure, fall back to the cached shell
+        .catch(indexHTMLOrOffline),
+    );
+    return;
+  }
+
+  // 3) For all other GETs: network-first, fallback to cache
+  event.respondWith(
+    fetch(req)
+      .then((response) => {
+        if (response.ok) {
+          const clone = response.clone();
+          caches.open(CACHE_NAME).then((cache) => cache.put(req, clone));
+        }
+        return response;
+      })
+      .catch(async () => {
+        return caches
+          .match(req)
+          .then((cached) => {
+            return cached || indexHTMLOrOffline();
+          })
+          .catch(indexHTMLOrOffline);
+      })
+      .catch(indexHTMLOrOffline),
+  );
+});
@@ -28,11 +28,12 @@
    flex: 1;
  }

-  .lightweight-chart {
-    z-index: 30;
+  > .chart > legend,
+  > fieldset {
+    z-index: 20;
  }

-  > * {
-    /* z-index: 30; */
+  .lightweight-chart {
+    z-index: 40;
  }
 }
Author	SHA1	Message	Date
nym21	93289e8fca	release: v0.0.47	2025-06-08 20:35:36 +02:00
nym21	130d5057d4	server: readme: add index-t-value documentation	2025-06-08 20:35:26 +02:00
nym21	be492d5084	server: add support for /api/X-to-Y + fix query cli + add meta api endpoints	2025-06-08 20:30:53 +02:00
nym21	e0bf1d736f	query: add count param	2025-06-08 18:26:59 +02:00
nym21	5a6b71cbeb	server: add ddos protection	2025-06-08 17:06:36 +02:00
nym21	e6934cd5e2	release: v0.0.46	2025-06-08 16:06:27 +02:00
nym21	b5aada0792	websites: mv sw to root	2025-06-08 16:05:21 +02:00
nym21	165ea83ac3	websites: update service worker	2025-06-08 13:03:37 +02:00
nym21	440a82dee4	release: v0.0.45	2025-06-08 09:11:31 +02:00
nym21	9c2d3e5e26	server: fix existing folder endpoints	2025-06-08 09:10:55 +02:00
nym21	6fb6abcbe5	release: v0.0.44	2025-06-07 18:53:51 +02:00
nym21	dc449dafd1	websites: default: up deps + fix css	2025-06-07 18:53:34 +02:00
				`@@ -0,0 +1 @@`
				`export declare function reconcile<T extends U, U>(value: T, key: string \| ((item: NonNullable<any>) => any)): (state: U) => T;`