expr_tracker 0.5.0__tar.gz → 0.6.1__tar.gz

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/Cargo.lock

@@ -205,7 +205,7 @@ dependencies = [
 
 [[package]]
 name = "expr-tracker-native"
-version = "0.5.0"
+version = "0.6.1"
 dependencies = [
  "axum",
  "base64 0.22.1",

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "expr-tracker-native"
-version = "0.5.0"
+version = "0.6.1"
 edition = "2021"
 license = "MIT"
 publish = false

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: expr_tracker
-Version: 0.5.0
+Version: 0.6.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -100,7 +100,7 @@ and view config, summary, and spans across rotation segments.
 Enter the random key printed at startup in the viewer's login form. The default listener is
 `0.0.0.0`; use a trusted network or HTTPS/SSH for remote access.
 Use **Add run** to select each run's directory on the server.
-Added runs are remembered locally across reloads; subdirectories are not scanned for runs.
+Added runs are saved on the server and shared across browsers; subdirectories are not scanned for runs.
 See the [viewer guide](docs/guide/web-viewer.md) and
 [native build instructions](docs/native-development.md).
 

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/README.md

@@ -50,7 +50,7 @@ and view config, summary, and spans across rotation segments.
 Enter the random key printed at startup in the viewer's login form. The default listener is
 `0.0.0.0`; use a trusted network or HTTPS/SSH for remote access.
 Use **Add run** to select each run's directory on the server.
-Added runs are remembered locally across reloads; subdirectories are not scanned for runs.
+Added runs are saved on the server and shared across browsers; subdirectories are not scanned for runs.
 See the [viewer guide](docs/guide/web-viewer.md) and
 [native build instructions](docs/native-development.md).
 

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/docs/guide/web-viewer.md

@@ -18,13 +18,13 @@ through HTTPS). Keys are not stored in browser local storage or URLs.
 Login is remembered for 30 days, including browser and server restarts.
 **Sign out** revokes the session and clears its cookie. Scripted clients can still use HTTP Basic
 with username `et` and the startup key. Previously added runs are restored after login.
-`--root` only sets the directory picker's starting location. Use `--port` to
+`--root` sets the directory picker's initial location until a shared location is saved. Use `--port` to
 choose another local port. Add up to six runs to the workspace and use their
 checkboxes to compare them. Removing a run from the sidebar only removes it
 from the workspace, not from disk. Each run has its own stream/rank selector;
 sources are never silently merged.
 
-`et serve` stores the key and active sessions in
+`et serve` stores the key, active sessions, and shared workspace in
 `$XDG_STATE_HOME/expr_tracker/viewer-auth-<port>.json`, or
 `~/.local/state/expr_tracker/viewer-auth-<port>.json` when that variable is unset
 or relative. The file is private (`0600` on Unix), atomically updated, and locked
@@ -44,7 +44,7 @@ Display names come from `tracker.name` and `tracker.project` in the run's config
 not necessarily the directory basename. The viewer prefers `config.json`, then
 `config.trainer-r0.json`, then the first stream config. This optional identity
 read is size-limited and cached until the chosen config changes; missing or
-invalid identity metadata falls back to directory names. Saved browser entries
+invalid identity metadata falls back to directory names. Saved workspace entries
 refresh their display names automatically.
 The directory path is shown in the picker's editable path field.
 This is not a browser upload picker: with SSH forwarding, paths
@@ -52,30 +52,72 @@ refer to the remote training host, not your laptop. Relative paths are resolved
 against the startup `--root`; absolute paths can select any directory accessible
 to the server process, including directories outside the startup root.
 
-Added runs, their selected sources, colors, and checkbox states are saved in this
-browser's local storage and restored on reload. Removing a run updates that saved
-list. No metric data, config contents, or access keys are saved there. Different
-tabs do not change each other's live selection; a new tab or reload reads the
-last saved list. Live and manual refresh only reload explicitly added run
-directories. The URL separately saves the picker's starting location.
-If browser storage is unavailable, a warning is shown and runs remain usable
-for the current page. Unavailable saved directories remain listed with errors
-rather than being silently discarded.
-Files are never uploaded, modified, or deleted. Browsing directories
+Added runs, their selected sources, colors, checkbox states, and the picker's
+last added directory are saved on the server, alongside its private authentication
+state. All browsers signed in to the same viewer share this workspace; visible
+pages check for changes every three seconds, even when **Live** is off, and also
+when focused. Reloading or restarting the server retains the saved workspace.
+Concurrent edits are revision-checked: a stale edit is rejected and the latest
+workspace is reloaded instead of silently overwriting another browser's changes.
+Loading or saving failures display an error and retry control; failed saves do
+not replace the last confirmed state. Removing a run only updates the shared
+list, not the experiment files. Unavailable saved directories remain listed
+with errors rather than being silently discarded.
+
+Run directories are no longer read from or written to browser local storage.
+Legacy browser-only lists are not automatically published to the shared server;
+add those directories once to share them. Theme and per-chart preferences remain
+local to each browser. No metric data or experiment config contents are persisted
+in the shared workspace. Live and manual refresh only reload explicitly added
+run directories. A `?root=...` bookmark can override the picker's starting location
+for that page until a run is added.
+
+Experiment files are never uploaded, modified, or deleted. Browsing directories
 with more than 10,000 entries fails explicitly; enter a child directory path
 directly instead.
 
 ## Curve comparison
 
-The React + shadcn/ui workspace uses single-line run rows. Metrics are grouped
+The React + shadcn/ui workspace arranges independent rounded panels on a shared
+canvas. The Runs panel contains the application icon and name, run search, and
+the run list. The plus icon beside run search adds a directory. Its bottom row
+groups the **Live** toggle button, **Refresh**, and **Settings**;
+settings contains theme switching and sign out. On desktop, drag the panel's
+right edge to resize its width without changing its height. The focused edge
+also accepts Left/Right (Shift for larger changes), Home to reset, and Escape to cancel a drag.
+The button beside **Experiment tracker** collapses the desktop panel into a narrow
+rail. The application icon becomes the expand button, followed by Add and each
+run's colored checkbox; hover or focus a checkbox to see its run name.
+The rail shows all runs even when the expanded list is filtered, and keeps Live,
+Refresh, and Settings available. Expand again to restore the previous width and
+search without changing selection or reloading charts.
+Desktop collapse and mobile management expansion are saved independently in this
+browser and restored on reload. A warning appears if browser storage is unavailable.
+Chart panels resize with the available space without reloading their data.
+Source, details, and remove actions appear when a run is hovered or keyboard
+focused, remain visible while its source menu is open, and are always available
+on touch screens. Narrow screens use wider canvas margins and a compact Runs panel:
+scroll the named run chips horizontally to select runs, or expand management for
+source, details, and remove actions. Add, Live, Refresh, and Settings remain available.
+Run and metric search fields are hidden on narrow screens, and `/` does not focus search.
+Chart pin, settings, and expand actions likewise appear on hover or keyboard focus,
+and stay visible on touch screens. The resize grip appears only when hovered,
+keyboard focused, or dragged; search fields use a thin inset focus indicator.
+Dropdown menus share the panels' compact radii, surface colors, and subtle borders.
+
+The workspace uses single-line run rows. Metrics are grouped
 by the first segment of their name:
 `train/loss` and `train/optimizer/lr` appear under **train**; names without a
-namespace appear under **Other**. Each section shows six charts per page, with
-left/right arrows for navigation. Search resets pagination to the first matching
+namespace appear under **Other**. Each section has independent **Columns** and
+**Rows** dropdowns, both accepting 1–5 (default 4 columns and 2 rows).
+Page capacity is columns times rows, so the default desktop
+page shows up to eight charts in two rows. Left/right arrows navigate pages.
+Narrow screens use one column and the same configured row count.
+Search or a layout change resets pagination to the first matching
 page; groups can also be collapsed. Only the current page is queried and rendered.
 The sidebar contains
 only runs; each row provides source selection, details, and removal controls.
-Search, axis, and layout share one compact sticky toolbar (horizontally
+Search and axis share one rounded sticky toolbar panel (horizontally
 scrollable on narrow screens). Search filters charts immediately, matching full metric
 names case-insensitively (multiple words must all match). Press `/` to focus
 search and Escape to clear it. The header theme button switches between light
@@ -84,9 +126,31 @@ and dark themes, including chart axes and series colors, and saves the preferenc
 Each uPlot chart overlays the selected runs with consistent colors, with its
 legend centered above the plot. Values and the hovered step/time appear only in
 that chart's hover tooltip; cursors are not synchronized across charts.
-Use **Step** or **Wall time** to change
-alignment, and the layout buttons for
-one or two columns. Each chart can expand into a focused view. On narrow screens,
+Each series shows its actual nearest sample, never an interpolated value.
+Ties choose the left sample. The matched sample is highlighted with a larger
+marker, and the tooltip heading snaps to an actual sampled step/time.
+Use **Step**, **Wall time**, or **Relative time** to change alignment.
+Plots show only the left and bottom axis borders, with short outward ticks and
+horizontal grid lines. Y-axis space fits its labels to avoid excessive left
+padding. The X axis includes the first and last plotted
+data values, suppressing nearby regular ticks; endpoint labels are stacked when
+needed to remain readable in narrow charts. These details also appear in PNG exports.
+Relative time is elapsed time since the selected source's earliest valid
+timestamp, independently for each run, displayed in seconds, minutes, hours, or
+days. Filtering steps or downsampling does not reset that origin; records without
+valid timestamps are skipped with a warning.
+Each chart's pin button adds a copy to a separate **Pinned** section above
+the namespace groups, keeping the chart in its original section. Unpinning
+only removes the pinned copy. Both copies share the metric's chart settings.
+Pinned charts support the same rows, paging, filtering, and focus controls.
+Hover a chart title to reveal its grab handle, then drag it before or after
+another chart in the same section. Hold within 48 pixels of either section edge
+for 650 ms to turn a page while dragging; release over a chart to place it.
+Escape cancels a drag. Focused titles also support arrow-key reordering:
+left/right move one position, up/down move one row. Pinned and original sections
+have independent ordering. Pins, ordering, and each section's column and row counts are remembered in the current browser, independently of
+the server-synchronized run directories.
+Each chart can expand into a focused full-width view. On narrow screens,
 the sidebar controls collapse so curves remain the primary content.
 
 ### Per-chart settings
@@ -109,6 +173,41 @@ changes do not reread logs or alter recorded values. Hover tooltips show the
 displayed values and identify active EMA smoothing. **Reset** restores the
 default controls; apply them to save the reset.
 
+### Combining sources
+
+Open an existing chart's settings and change **Source mode** from **Selected source**
+to **Overlay**, **Sum**, **Mean**, **Maximum**, or **Minimum**. The chart always
+shows the same metric; aggregation combines its values across source files within
+each experiment, never different metrics or different experiments.
+Choose sources with the checkboxes, or enter a wildcard under **Source pattern**:
+`rollout-*` selects `metrics.rollout-0.jsonl` through `metrics.rollout-7.jsonl`;
+`trainer-*` selects trainer sources. Full filenames such as
+`metrics.rollout-*.jsonl` also work. `*` matches any text and `?` matches one
+character. A nonempty pattern replaces the manual selection and automatically
+matches new available sources. Up to 128 inputs
+are supported; an empty or excessive match is reported explicitly.
+
+Overlay draws the selected sources as separate curves. Source colors distinguish
+sources, and different run line styles distinguish runs; legends and tooltips
+include both names. Reducers produce one curve per run, combining the selected
+sources in the same recorded step. Runs are never aggregated together.
+Only finite values present at that step participate: missing values are not
+interpolated, forward-filled, or replaced with zero, and an entirely missing step
+produces no sample. Means divide by the number of present values.
+Reduction happens on the server before downsampling, EMA smoothing, and log filtering.
+Time axes use the earliest selected-source timestamp at each step. Relative time
+starts at the earliest timestamp across the selected sources' entire histories,
+independently of metric presence, query window, and downsampling.
+Numeric overflow is reported and omitted.
+
+The original metric remains the chart's title and position; its subtitle identifies
+the combination mode and input count. Other charts and source logs are unchanged.
+Choices are saved with that chart's browser-local settings, shared by its pinned
+copy, and included in PNG exports. Source aggregation does not change the run's
+selected source in the sidebar. Cached requests are reused when returning to the
+same operation and inputs. Legacy metric-aggregation settings are removed on load,
+while smoothing, axes, height, and other appearance settings are preserved.
+
 ### Records and streaming
 
 Each run's **Details** button opens config/summary, paginated records, and spans
@@ -132,7 +231,8 @@ There is no workspace-wide metric limit. A Web Worker streams history over
 `/api/history/stream` as NDJSON and prepares finite per-run x/y arrays
 off the UI thread. Transferable `Float64Array` buffers move to uPlot's shared-axis,
 per-series data mode without cloning thousands of boxed numbers on the UI thread.
-Queries contain up to six metrics for the current page and share two concurrent
+Queries contain only metrics on the current section page (up to 20 with four
+columns and five rows) and share two concurrent
 streams. Each native chunk contains at most 256 points, with a bounded two-chunk
 channel providing backpressure. Disconnecting cancels the scan.
 
@@ -141,6 +241,10 @@ row (including 5,000+ points); larger ranges use extrema-preserving downsampling
 Sections initialize when approached. Scrolling away pauses subscriptions, drawing,
 after a short grace period; initialized canvases stay
 mounted so scrolling back does not repeatedly destroy and recreate plots.
+Completed views with unchanged request and transform keys reuse their current
+data without resubscribing or transferring worker snapshots. Canvas drawing is
+skipped unless data, dimensions, theme, or chart settings change. Changed source
+metadata and manual refresh still invalidate offscreen views when revisited.
 Hover values update lightweight DOM labels rather than rerendering React charts.
 Shared worker streams avoid
 duplicate scans for neighboring charts, and completed sources are cached with
@@ -161,7 +265,8 @@ workspace or refetching successful sources.
 
 Live is off by default. When enabled, it polls metadata every three seconds while the page is visible, fetching new
 curves only when source metadata changes. Visible charts update in place; old
-data remains visible with a loading indicator during refresh. Manual **Refresh**
+data remains visible during refresh. Each loading chart's border pulses instead
+of displaying a spinner; reduced-motion mode uses a steady border. Manual **Refresh**
 also invalidates curve queries. It refreshes selected runs, not unselected
 sidebar entries, and sees only complete rows already written to disk. It cannot display
 an open metric row or records still held in the training process's write buffer.

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "expr_tracker"
-version = "0.5.0"
+version = "0.6.1"
 description = "Local-first experiment tracking with queryable history and expression-based alerts on your training metrics"
 readme = "README.md"
 license = "MIT"
@@ -97,6 +97,7 @@ include = [
     { path = "web/package-lock.json", format = "sdist" },
     { path = "web/components.json", format = "sdist" },
     { path = "web/index.html", format = "sdist" },
+    { path = "web/public/**/*", format = "sdist" },
     { path = "web/tsconfig.json", format = "sdist" },
     { path = "web/vite.config.ts", format = "sdist" },
     { path = "web/vitest.config.ts", format = "sdist" },

expr_tracker-0.6.1/rust/viewer/aggregate.rs

@@ -0,0 +1,217 @@
+use super::*;
+
+#[derive(Default)]
+struct Reduction {
+    count: usize,
+    scale: f64,
+    sum: f64,
+    min: f64,
+    max: f64,
+}
+
+impl Reduction {
+    fn push(&mut self, value: f64) {
+        if self.count == 0 {
+            self.min = value;
+            self.max = value;
+        } else {
+            self.min = self.min.min(value);
+            self.max = self.max.max(value);
+        }
+        let scale = value.abs();
+        if scale > self.scale {
+            self.sum *= self.scale / scale;
+            self.scale = scale;
+        }
+        if self.scale > 0.0 {
+            self.sum += value / self.scale;
+        }
+        self.count += 1;
+    }
+
+    fn value(&self, mode: &str) -> Option<f64> {
+        if self.count == 0 {
+            return None;
+        }
+        Some(match mode {
+            "min" => self.min,
+            "max" => self.max,
+            "mean" => (self.sum / self.count as f64) * self.scale,
+            _ => self.sum * self.scale,
+        })
+    }
+}
+
+pub(super) fn sources(
+    viewer: &Viewer,
+    run: &Run,
+    query: &HistoryQuery,
+    cancelled: impl Fn() -> bool,
+) -> Result<CachedLog> {
+    let files: Vec<String> = serde_json::from_str(
+        query
+            .files
+            .as_deref()
+            .ok_or_else(|| invalid("Source aggregation requires files"))?,
+    )?;
+    let mode = query.aggregation.as_deref().unwrap_or("");
+    if query.file.is_some() || !["sum", "mean", "max", "min"].contains(&mode) {
+        return Err(invalid(
+            "Choose sum, mean, max or min with files, not a single file",
+        ));
+    }
+    if files.is_empty() || files.len() > 128 {
+        return Err(invalid("Select between 1 and 128 metric sources per run"));
+    }
+    let paths = files
+        .iter()
+        .map(|file| {
+            let (path, spans) = viewer.file(run, Some(file))?;
+            if spans {
+                return Err(invalid("Aggregation requires metric sources"));
+            }
+            Ok(path)
+        })
+        .collect::<Result<Vec<_>>>()?;
+    if paths.iter().collect::<BTreeSet<_>>().len() != paths.len() {
+        return Err(invalid("Duplicate aggregation sources"));
+    }
+    let metrics: Vec<String> = serde_json::from_str(&query.metrics)?;
+    if metrics.is_empty() || metrics.len() > 128 || metrics.iter().any(|metric| metric.len() > 4096)
+    {
+        return Err(invalid("Select between 1 and 128 metrics"));
+    }
+    let mut output = CachedLog::new(viewer.stopping.clone())?;
+    output
+        .db
+        .execute_batch("CREATE TABLE source_rows(step TEXT, sort TEXT, time REAL, data TEXT);")?;
+    let transaction = output.db.transaction()?;
+    let mut missing_sources = 0;
+    {
+        let mut insert = transaction.prepare("INSERT INTO source_rows VALUES (?1,?2,?3,?4)")?;
+        for path in paths {
+            viewer.with_log(&path, false, |log| {
+                output.corrupt += log.corrupt;
+                output.surrogates |= log.surrogates;
+                if !metrics.iter().any(|metric| log.metrics.contains(metric)) {
+                    missing_sources += 1;
+                }
+                let mut statement = log.db.prepare("SELECT step,sort,time,data FROM records")?;
+                let mut rows = statement.query([])?;
+                while let Some(row) = rows.next()? {
+                    if cancelled() {
+                        return Err(invalid("Aggregation disconnected"));
+                    }
+                    let raw: String = row.get(3)?;
+                    let value: Value = serde_json::from_str(&raw)?;
+                    let values: Map<String, Value> = metrics
+                        .iter()
+                        .filter_map(|metric| {
+                            value
+                                .get(metric)
+                                .map(|value| (metric.clone(), value.clone()))
+                        })
+                        .collect();
+                    insert.execute(params![
+                        row.get::<_, String>(0)?,
+                        row.get::<_, String>(1)?,
+                        row.get::<_, Option<f64>>(2)?,
+                        serde_json::to_string(&values)?
+                    ])?;
+                }
+                Ok(())
+            })?;
+        }
+    }
+    let mut overflow = 0;
+    let mut nonfinite = 0;
+    {
+        let mut statement =
+            transaction.prepare("SELECT step,sort,time,data FROM source_rows ORDER BY sort")?;
+        let mut rows = statement.query([])?;
+        let mut insert = transaction
+            .prepare("INSERT INTO records(step,sort,ordinal,time,data) VALUES (?1,?2,?3,?4,?5)")?;
+        let mut current: Option<(String, String)> = None;
+        let mut time: Option<f64> = None;
+        let mut values: Vec<Reduction> = (0..metrics.len()).map(|_| Reduction::default()).collect();
+        let mut ordinal = 0i64;
+        let mut flush =
+            |step: &str, sort: &str, time: Option<f64>, values: &[Reduction]| -> Result<()> {
+                let mut data = Map::new();
+                data.insert("_step".into(), serde_json::from_str(step)?);
+                if let Some(time) = time {
+                    data.insert("_time".into(), Value::from(time));
+                }
+                for (metric, reduction) in metrics.iter().zip(values) {
+                    if let Some(value) = reduction.value(mode) {
+                        if value.is_finite() {
+                            data.insert(metric.clone(), Value::from(value));
+                        } else {
+                            overflow += 1;
+                        }
+                    }
+                }
+                insert.execute(params![
+                    step,
+                    sort,
+                    ordinal,
+                    time,
+                    serde_json::to_string(&data)?
+                ])?;
+                ordinal += 1;
+                Ok(())
+            };
+        while let Some(row) = rows.next()? {
+            if cancelled() {
+                return Err(invalid("Aggregation disconnected"));
+            }
+            let step: String = row.get(0)?;
+            let sort: String = row.get(1)?;
+            if current
+                .as_ref()
+                .is_some_and(|(previous, _)| previous != &step)
+            {
+                let (previous, previous_sort) = current.as_ref().unwrap();
+                flush(previous, previous_sort, time, &values)?;
+                values = (0..metrics.len()).map(|_| Reduction::default()).collect();
+                time = None;
+            }
+            current = Some((step, sort));
+            if let Some(timestamp) = row.get::<_, Option<f64>>(2)? {
+                time = Some(time.map_or(timestamp, |previous| previous.min(timestamp)));
+            }
+            let raw: String = row.get(3)?;
+            let data: Value = serde_json::from_str(&raw)?;
+            for (metric, reduction) in metrics.iter().zip(&mut values) {
+                if let Some(value) = data.get(metric) {
+                    if let Some(value) = finite_number(value) {
+                        reduction.push(value);
+                    } else if value.get("$et.nonfinite").is_some() || value.is_number() {
+                        nonfinite += 1;
+                    }
+                }
+            }
+        }
+        if let Some((step, sort)) = current {
+            flush(&step, &sort, time, &values)?;
+        }
+    }
+    transaction.execute("DROP TABLE source_rows", [])?;
+    transaction.commit()?;
+    if missing_sources > 0 {
+        output.extra_warnings.push(format!(
+            "{missing_sources} selected sources have no recorded values for the requested metrics; missing values are ignored."
+        ));
+    }
+    if overflow > 0 {
+        output.extra_warnings.push(format!(
+            "{overflow} aggregated values exceeded the numeric range and were omitted."
+        ));
+    }
+    if nonfinite > 0 {
+        output.extra_warnings.push(format!(
+            "{nonfinite} non-finite source observations ignored."
+        ));
+    }
+    Ok(output)
+}

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/rust/viewer/auth_store.rs

@@ -16,6 +16,8 @@ struct Saved {
     version: u8,
     key: String,
     sessions: Vec<Session>,
+    #[serde(default)]
+    workspace: workspace::Workspace,
 }
 
 pub(super) struct AuthStore {
@@ -49,6 +51,7 @@ impl AuthStore {
             version: 1,
             key,
             sessions: Vec::new(),
+            workspace: workspace::Workspace::default(),
         };
         let mut lock = None;
         let path = path
@@ -115,6 +118,7 @@ impl AuthStore {
         {
             return Err(invalid_state());
         }
+        saved.workspace.validate().map_err(|_| invalid_state())?;
         let store = Self {
             data: Mutex::new(saved),
             path,
@@ -144,6 +148,29 @@ impl AuthStore {
         self.data.lock().key.clone()
     }
 
+    pub(super) fn workspace(&self) -> workspace::Workspace {
+        self.data.lock().workspace.clone()
+    }
+
+    pub(super) fn save_workspace(&self, mut workspace: workspace::Workspace) -> Result<workspace::Workspace> {
+        workspace.validate()?;
+        let mut data = self.data.lock();
+        if workspace.revision != data.workspace.revision {
+            return Err(Error(
+                StatusCode::CONFLICT,
+                "Workspace changed in another browser. Shared runs have been reloaded; please try again.".into(),
+            ));
+        }
+        workspace.revision = workspace.revision.checked_add(1)
+            .filter(|revision| *revision < (1u64 << 53))
+            .ok_or_else(|| invalid("Workspace revision limit reached"))?;
+        let mut next = data.clone();
+        next.workspace = workspace.clone();
+        self.persist(&next)?;
+        *data = next;
+        Ok(workspace)
+    }
+
     pub(super) fn contains_at(&self, token: &str, now: u64) -> bool {
         self.data.lock().sessions.iter().any(|session| {
             session.expires > now && auth::matches(token.as_bytes(), session.token.as_bytes())

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/rust/viewer/index.rs

@@ -21,6 +21,7 @@ pub(super) struct CachedLog {
     pub(super) metrics: BTreeSet<String>,
     pub(super) corrupt: u64,
     pub(super) surrogates: bool,
+    pub(super) extra_warnings: Vec<String>,
     pub(super) stopping: Arc<AtomicBool>,
 }
 
@@ -48,12 +49,13 @@ impl CachedLog {
             metrics: BTreeSet::new(),
             corrupt: 0,
             surrogates: false,
+            extra_warnings: Vec::new(),
             stopping,
         })
     }
 
     pub(super) fn warnings(&self) -> Vec<String> {
-        let mut warnings = Vec::new();
+        let mut warnings = self.extra_warnings.clone();
         if self.corrupt > 0 {
             warnings.push(format!("Skipped {} malformed records.", self.corrupt));
         }

expr_tracker-0.6.1/rust/viewer/log_files.rs

@@ -0,0 +1,30 @@
+use super::LogFile;
+
+pub(super) fn parse(name: &str) -> Option<LogFile> {
+    let stem = name.strip_suffix(".jsonl")?;
+    let mut parts: Vec<&str> = stem.split('.').collect();
+    let kind = parts.first()?;
+    if !["metrics", "spans"].contains(kind) {
+        return None;
+    }
+    let mut rank = 0;
+    if parts.len() > 1 {
+        if let Some(number) = parts
+            .last()?
+            .strip_prefix("rank")
+            .and_then(|rank| rank.parse::<u64>().ok())
+        {
+            rank = number;
+            parts.pop();
+        }
+    }
+    if parts.len() > 2 {
+        return None;
+    }
+    Some(LogFile {
+        name: name.into(),
+        kind: parts[0].into(),
+        stream: parts.get(1).map(|stream| (*stream).into()),
+        rank,
+    })
+}

{expr_tracker-0.5.0 → expr_tracker-0.6.1}/rust/viewer/stream.rs

@@ -44,7 +44,9 @@ fn query(log: &CachedLog, query: &HistoryQuery, metrics: &[String], sender: &Sen
         sender,
         json!({"type":"start", "metrics":metrics, "total":total, "warnings":log.warnings()}),
     )?;
-    let time = query.axis.as_deref() == Some("time");
+    let axis = query.axis.as_deref().unwrap_or("step");
+    let time = axis != "step";
+    let origin = time_origin(log, axis)?;
     let sql = if time {
         "SELECT data FROM records WHERE sort>=?1 AND sort<?2 ORDER BY time,sort"
     } else {
@@ -88,7 +90,11 @@ fn query(log: &CachedLog, query: &HistoryQuery, metrics: &[String], sender: &Sen
                     number
                 })
                 .collect();
-            let point = Point { at, x, ys };
+            let point = Point {
+                at,
+                x: x - origin,
+                ys,
+            };
             if total <= limit {
                 points.push(point);
             } else {
@@ -138,7 +144,7 @@ pub(super) async fn history(
             "max_points is too small for the selected metric count",
         ));
     }
-    if !["step", "time"].contains(&query_args.axis.as_deref().unwrap_or("step")) {
+    if !["step", "time", "relative"].contains(&query_args.axis.as_deref().unwrap_or("step")) {
         return Err(invalid("Unknown chart axis"));
     }
     let low = bound(query_args.from_step.as_deref())?;
@@ -155,6 +161,10 @@ pub(super) async fn history(
         let result = (|| {
             let root = viewer.resolve_root(query_args.root.as_deref())?;
             let run = viewer.run(&root, &query_args.run)?;
+            if query_args.files.is_some() || query_args.aggregation.is_some() {
+                let log = aggregate::sources(&viewer, &run, &query_args, || sender.is_closed())?;
+                return query(&log, &query_args, &metrics, &sender);
+            }
             let (path, spans) = viewer.file(&run, query_args.file.as_deref())?;
             if spans {
                 return Err(invalid("Charts require a metric source"));