feat: Website with live demo

Author: ImpossibleReality

.github/workflows/pages.yml

@@ -0,0 +1,79 @@
+name: Pages
+
+on:
+  push:
+    branches: [main]
+    # The site is a prerendered SvelteKit page that embeds the calculator core
+    # as WebAssembly, so a core change is a site change.
+    paths:
+      - "website/**"
+      - "wasm/**"
+      - "core/**"
+      - "Cargo.toml"
+      - "Cargo.lock"
+      - ".github/workflows/pages.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Let an in-flight deployment finish rather than cancelling it: a cancelled
+# deploy-pages run can leave the live site on the previous commit.
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ". -> target"
+
+      # Pinned to the version the wasm crate's wasm-opt flags were tuned for.
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: wasm-pack@0.12.1
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        working-directory: website
+        run: bun install --frozen-lockfile
+
+      # `bun run build` runs wasm-pack first, then vite.
+      - name: Build the site
+        working-directory: website
+        run: bun run build
+
+      - name: Check the build output
+        shell: bash
+        run: |
+          set -euo pipefail
+          test -f website/build/index.html
+          test -f website/build/CNAME
+          # adapter-static emits the wasm module as a hashed asset; a missing one
+          # means the demo would load into a dead calculator.
+          test -n "$(find website/build/_app -name '*.wasm' -print -quit)"
+
+      - uses: actions/configure-pages@v5
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: website/build
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

Cargo.lock

@@ -5,6 +5,7 @@ members = [
     "core",
     "conformance",
     "desktop",
+    "wasm",
 ]
 
 [profile.release]

Cargo.toml

@@ -18,7 +18,13 @@ mendeleev = { version = "=0.8.4", default-features = false, features = [
 astro-float = { version = "0.9.6", default-features = false, features = [
     "std",
 ] }
-# Dynamic (currency) units: live rates from the Frankfurter API, cached to disk.
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+jiff = { version = "0.2.35", default-features = false, features = ["std", "tz-system"] }
+
+# Dynamic (currency) units fetch live rates and cache them to disk. Neither is
+# possible on wasm, where the host installs rates instead.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Minimal reqwest: no default features (drops http2/h2, native-tls, system-proxy,
 # charset) and `rustls-no-provider` so we supply the lighter `ring` crypto
 # provider instead of the large aws-lc-rs C library. JSON is parsed via
@@ -28,7 +34,8 @@ reqwest = { version = "0.13", default-features = false, features = [
     "rustls-no-provider",
 ] }
 rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
 dirs = "6"
-jiff = { version = "0.2.35", default-features = false, features = ["std", "tz-system"] }
+
+# jiff reads the clock and the local zone through JavaScript on wasm.
+[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
+jiff = { version = "0.2.35", default-features = false, features = ["std", "tz-system", "js"] }

core/Cargo.toml

@@ -1,18 +1,28 @@
 //! Dynamic (currency) units.
 //!
 //! Currencies are resolved at evaluation time using the [Frankfurter](https://frankfurter.dev) API.
-//! Exchange rates are cached to disk and refresh at most once an hour.
+//! Exchange rates are cached to disk and refresh at most once an hour. On wasm, where neither the
+//! network nor the disk is reachable from here, the host installs rates with
+//! [`install_static_rates`] instead.
 
 use crate::representations::Float;
-use serde::{Deserialize, Serialize};
+#[cfg(not(target_arch = "wasm32"))]
+use serde::Deserialize;
+use serde::Serialize;
 use std::collections::BTreeMap;
+#[cfg(not(target_arch = "wasm32"))]
 use std::path::PathBuf;
 use std::sync::{Mutex, OnceLock};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::{SystemTime, UNIX_EPOCH};
 
+#[cfg(not(target_arch = "wasm32"))]
 const FRANKFURTER_URL: &str = "https://api.frankfurter.dev/v1/latest";
+#[cfg(not(target_arch = "wasm32"))]
 const CACHE_TTL_SECS: u64 = 3600;
-const FETCH_TIMEOUT: Duration = Duration::from_secs(8);
+#[cfg(not(target_arch = "wasm32"))]
+const FETCH_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(8);
+#[cfg(not(target_arch = "wasm32"))]
 const RETRY_BACKOFF_SECS: u64 = 60;
 
 const CANONICAL: &str = "EUR";
@@ -103,36 +113,34 @@ fn currency_name(code: &str) -> &'static str {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 #[derive(Deserialize)]
 struct FrankfurterResponse {
     rates: BTreeMap<String, f64>,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize)]
+#[cfg_attr(not(target_arch = "wasm32"), derive(Deserialize))]
 struct CachedRates {
     fetched_at: u64,
     rates: BTreeMap<String, f64>,
 }
 
+#[derive(Default)]
 struct State {
     table: Option<CachedRates>,
     override_rates: Option<BTreeMap<String, f64>>,
+    #[cfg(not(target_arch = "wasm32"))]
     loaded_disk: bool,
+    #[cfg(not(target_arch = "wasm32"))]
     refreshing: bool,
+    #[cfg(not(target_arch = "wasm32"))]
     last_attempt: u64,
 }
 
 fn state() -> &'static Mutex<State> {
     static STATE: OnceLock<Mutex<State>> = OnceLock::new();
-    STATE.get_or_init(|| {
-        Mutex::new(State {
-            table: None,
-            override_rates: None,
-            loaded_disk: false,
-            refreshing: false,
-            last_attempt: 0,
-        })
-    })
+    STATE.get_or_init(|| Mutex::new(State::default()))
 }
 
 pub fn install_static_rates(pairs: &[(&str, f64)]) {
@@ -141,37 +149,43 @@ pub fn install_static_rates(pairs: &[(&str, f64)]) {
     state().lock().unwrap().override_rates = Some(rates);
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn now() -> u64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .map(|d| d.as_secs())
         .unwrap_or(0)
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn is_fresh(table: &Option<CachedRates>) -> bool {
     table
         .as_ref()
         .is_some_and(|t| now().saturating_sub(t.fetched_at) < CACHE_TTL_SECS)
 }
 
 fn rate(code: &str) -> Option<Float> {
+    #[cfg_attr(target_arch = "wasm32", allow(unused_mut))]
     let mut state = state().lock().unwrap();
 
     if let Some(rates) = &state.override_rates {
         return rates.get(code).and_then(|r| to_float(*r));
     }
 
-    if !state.loaded_disk {
-        state.loaded_disk = true;
-        state.table = load_disk();
-    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        if !state.loaded_disk {
+            state.loaded_disk = true;
+            state.table = load_disk();
+        }
 
-    let stale = !is_fresh(&state.table);
-    let backoff_elapsed = now().saturating_sub(state.last_attempt) >= RETRY_BACKOFF_SECS;
-    if stale && !state.refreshing && backoff_elapsed {
-        state.last_attempt = now();
-        state.refreshing = true;
-        spawn_refresh();
+        let stale = !is_fresh(&state.table);
+        let backoff_elapsed = now().saturating_sub(state.last_attempt) >= RETRY_BACKOFF_SECS;
+        if stale && !state.refreshing && backoff_elapsed {
+            state.last_attempt = now();
+            state.refreshing = true;
+            spawn_refresh();
+        }
     }
 
     state
@@ -182,6 +196,7 @@ fn rate(code: &str) -> Option<Float> {
         .and_then(|r| to_float(*r))
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn spawn_refresh() {
     std::thread::spawn(|| {
         let fetched = fetch();
@@ -205,6 +220,7 @@ fn to_float(rate: f64) -> Option<Float> {
     Float::parse(&format!("{rate}")).ok()
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn fetch() -> Option<BTreeMap<String, f64>> {
     ensure_tls_provider();
     let client = reqwest::blocking::Client::builder()
@@ -218,6 +234,7 @@ fn fetch() -> Option<BTreeMap<String, f64>> {
     Some(rates)
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn ensure_tls_provider() {
     use std::sync::Once;
     static ONCE: Once = Once::new();
@@ -226,18 +243,21 @@ fn ensure_tls_provider() {
     });
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn cache_path() -> Option<PathBuf> {
     let mut path = dirs::cache_dir()?;
     path.push("siffra");
     path.push("frankfurter.json");
     Some(path)
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn load_disk() -> Option<CachedRates> {
     let data = std::fs::read_to_string(cache_path()?).ok()?;
     serde_json::from_str(&data).ok()
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn save_disk(table: &CachedRates) {
     let Some(path) = cache_path() else {
         return;

core/src/representations/dimension/currency.rs

@@ -5,6 +5,7 @@ mod expression;
 mod float;
 mod format;
 pub mod ladder;
+mod number_display;
 mod value;
 
 pub use basis::{Basis, CalendarReadings};
@@ -13,4 +14,5 @@ pub use display::{DisplayHints, Granularity};
 pub use expression::*;
 pub use float::*;
 pub use format::{FormattedValue, format_value};
+pub use number_display::{NumberDisplay, format_number_for_characters, format_repeating_decimal};
 pub use value::*;

core/src/representations/mod.rs

@@ -1,8 +1,9 @@
-use self::format::{NumberDisplay, format_number_for_characters, format_repeating_decimal};
 use super::layout::{Fonts, Metrics, row_rects};
 use crate::calculation::LineOutput;
+use siffra::representations::{
+    NumberDisplay, format_number_for_characters, format_repeating_decimal,
+};
 
-pub mod format;
 use crate::ui::theme;
 use gpui::{
     App, Bounds, Element, ElementId, Font, GlobalElementId, Hsla, InspectorElementId, IntoElement,

desktop/src/editor/result/format.rs …re/src/representations/number_display.rsdesktop/src/editor/result/format.rs renamed to core/src/representations/number_display.rs desktop/src/editor/result/format.rs renamed to core/src/representations/number_display.rs

@@ -0,0 +1,28 @@
+[package]
+name = "siffra-wasm"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+# wasm-pack's bundled wasm-opt predates the features rustc now emits by default.
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = [
+    "-O",
+    "--enable-bulk-memory",
+    "--enable-nontrapping-float-to-int",
+    "--enable-sign-ext",
+    "--enable-mutable-globals",
+    "--enable-reference-types",
+]
+
+[dependencies]
+siffra = { path = "../core" }
+wasm-bindgen = "0.2"
+serde = { version = "1", features = ["derive"] }
+serde-wasm-bindgen = "0.6"