@runwisp/ui 1.4.0 → 1.5.1

package/src/lib/components/dashboard/RunsList.svelte

@@ -19,9 +19,8 @@
     import type { RunMotion } from "../../utils/run-motion.js";
     import EmptyState from "../EmptyState.svelte";
     import RunFilterPopover from "./RunFilterPopover.svelte";
-    import type { Run } from "./types.js";
-    import type { RunSelector, RunStatus } from "@runwisp/common";
-    import { getRunStatusConfig, runDisplayStatus } from "./status-config.js";
+    import { displayStatus, type Run, type RunSelector, type RunStatus } from "@runwisp/common";
+    import { RUN_STATUS_CONFIG } from "./status-config.js";
     import {
         activeDimensions,
         clearDimension,
@@ -71,7 +70,6 @@
         onBulkRerun,
         getInstanceCount = () => 1,
         motion,
-        flush = false,
         outputSearch = false,
         outputQuery = "",
         outputMatches = null,
@@ -105,11 +103,6 @@
         // Which runs arrived or were removed live moments ago: their rows animate
         // in or out. Page loads, scrolling and filtering never do.
         motion?: RunMotion;
-        // Flush rail mode (task detail page): render as a borderless rail that
-        // fills its column and is divided from the detail panel by a single right
-        // border — no card chrome of its own. Default renders the standalone card
-        // the cross-task /runs grid expects.
-        flush?: boolean;
         // Output search (history rail): filters runs by what they printed. The
         // search box lives in the app header now; the parent owns the box, the
         // query, and the async log search. This component just renders the
@@ -121,7 +114,7 @@
         // null = no active search; the full list shows.
         outputMatches?: Map<string, RunOutputMatch> | null;
         // True while a query is typed but its results aren't in yet (debounce
-        // window or request in flight) — the rail shows its searching shimmer.
+        // window or request in flight), the rail shows its searching shimmer.
         outputSearchPending?: boolean;
     } = $props();
 
@@ -131,7 +124,7 @@
     const OVERSCAN = 8;
     const LOAD_AHEAD = 10;
 
-    // Selection model: two modes —
+    // Selection model: two modes,
     //   1. explicit:  user picked specific rows. explicitIds holds them.
     //   2. selectAll: "all matching the current filter". exceptIds holds opt-outs.
     let selectAllMode = $state(false);
@@ -146,13 +139,13 @@
 
     // Loaded runs that matched the output search, in list order. A match in a
     // not-yet-loaded run can't be shown until the rail scrolls far enough to
-    // load it — the count reflects what's loaded, not the whole history.
+    // load it, the count reflects what's loaded, not the whole history.
     const matchedRuns = $derived(
         outputMatches ? items.filter((r: Run) => outputMatches.has(r.id)) : [],
     );
 
     // Split the matching line into [before, match, after] around the first
-    // occurrence of the query, windowed to keep the match in view — mirrors the
+    // occurrence of the query, windowed to keep the match in view, mirrors the
     // artifact's snippet. Rendered as plain text spans (Svelte auto-escapes), so
     // no untrusted HTML ever reaches the DOM.
     interface HighlightParts {
@@ -392,17 +385,15 @@
     });
 </script>
 
+<!-- A borderless rail that fills its column, divided from the detail panel by
+     a single right border. -->
 <div
-    class={flush
-        ? "flex h-full w-full flex-col overflow-hidden border-b border-outline bg-surface md:w-[300px] md:shrink-0 md:border-r md:border-b-0"
-        : "flex flex-col overflow-hidden rounded-[4px] border border-outline bg-surface-raised shadow-sm md:col-span-4 lg:col-span-3"}
+    class="flex h-full w-full flex-col overflow-hidden border-b border-outline bg-surface md:w-[300px] md:shrink-0 md:border-r md:border-b-0"
 >
     <div
         class="flex shrink-0 items-center gap-2 border-b px-3 py-2 {hasSelection
             ? 'border-outline-faint bg-primary-soft/40'
-            : flush
-              ? 'border-transparent bg-surface'
-              : 'border-outline-faint bg-surface-sunken'}"
+            : 'border-transparent bg-surface'}"
     >
         {#if bulkActions}
             <label
@@ -483,7 +474,7 @@
             </span>
             <div class="ml-auto flex items-center gap-1">
                 {#if showFilters}
-                    <RunFilterPopover bind:filters {showTask} {tasks} compact={flush} />
+                    <RunFilterPopover bind:filters {showTask} {tasks} />
                 {/if}
                 <Button
                     variant="ghost"
@@ -609,8 +600,8 @@
     </div>
 </div>
 
-<!-- Status dot. With bulk actions on it fades out — on row hover, or whenever a
-     selection exists — so the row checkbox can take its place over it. -->
+<!-- Status dot. With bulk actions on it fades out, on row hover, or whenever a
+     selection exists, so the row checkbox can take its place over it. -->
 <!-- Placeholders shaped like this list's run rows (same padding, dot, text
      and right readout), while a search or the first page is in flight. -->
 {#snippet skeletonRows(label: string)}
@@ -688,8 +679,8 @@
 {/snippet}
 
 {#snippet runRowButton(run: Run, isActive: boolean, match: RunOutputMatch | undefined)}
-    {@const dstatus = runDisplayStatus(run)}
-    {@const config = getRunStatusConfig(dstatus)}
+    {@const dstatus = displayStatus(run.status, run.endReason)}
+    {@const config = RUN_STATUS_CONFIG[dstatus]}
     {@const running = run.status === "running"}
     {@const spine = config.dot.replace(" animate-pulse", "")}
     {@const startedAt = run.startedAt ?? run.createdAt}
@@ -706,7 +697,7 @@
     >
         {#if showTaskName}
             <!-- Cross-task /runs variant: the same readout language as the task
-                 rail — status dot, status-colored outcome, mono right readout —
+                 rail, status dot, status-colored outcome, mono right readout,
                  with the task name carried as the primary. -->
             <div class="flex items-center gap-2.5">
                 {@render statusDot(config.color, running)}
@@ -744,7 +735,7 @@
                 </span>
             </div>
         {:else}
-            <!-- Task-rail variant (artifact ".run"): a single dense line —
+            <!-- Task-rail variant (artifact ".run"): a single dense line,
                  time · date · outcome, with a mono exit/duration readout.
                  leading-tight matches the artifact's ~1.2 line-height so the
                  (descender-less) text optically centers instead of riding high

package/src/lib/components/dashboard/cron-format.test.ts

@@ -52,7 +52,7 @@ describe("humanizeCron", () => {
         expect(result.isHumanized).toBe(false);
     });
 
-    it("falls back to raw for unparseable expressions — never 'Invalid'", () => {
+    it("falls back to raw for unparseable expressions, never 'Invalid'", () => {
         const result = humanizeCron("not a cron");
         expect(result.humanized).toBe("not a cron");
         expect(result.isHumanized).toBe(false);

package/src/lib/components/dashboard/cron-format.ts

@@ -2,8 +2,8 @@
 
 import cronstrue from "cronstrue";
 
-export interface HumanizedCron {
-    /** Display text — humanized when possible, otherwise the raw expression. */
+interface HumanizedCron {
+    /** Display text, humanized when possible, otherwise the raw expression. */
     humanized: string;
     /** The original cron expression, for tooltips. */
     raw: string;
@@ -51,7 +51,7 @@ function humanizeEvery(duration: string): string | null {
 /**
  * humanizeCron renders a cron expression as plain English ("Every 5 minutes").
  * Handles robfig's `@every <duration>` extension (cronstrue throws on it) and
- * falls back to the raw expression on anything unparseable — never "Invalid".
+ * falls back to the raw expression on anything unparseable, never "Invalid".
  */
 export function humanizeCron(cron: string): HumanizedCron {
     const raw = cron.trim();

package/src/lib/components/dashboard/run-filters.test.ts

@@ -6,13 +6,10 @@ import { END_REASONS } from "@runwisp/common";
 import {
     emptyRunFilters,
     FAILURE_STATUS_TOKEN,
-    NEEDS_ATTENTION_STATUSES,
-    isNeedsAttention,
     dimensionActive,
     activeDimensions,
     activeFilterCount,
     clearDimension,
-    clearPopoverFilters,
     humanizeStatus,
     triggerDescription,
     FILTERABLE_TRIGGERS,
@@ -29,7 +26,6 @@ import {
     exitCodeRangeActive,
     isExitCodeExprValid,
     exitCodeChipLabel,
-    exitCodePropChanged,
     type StatusBucket,
     type RunsListFilters,
 } from "./run-filters.js";
@@ -46,7 +42,7 @@ const base = (overrides: Partial<RunsListFilters> = {}): RunsListFilters => ({
 });
 
 describe("emptyRunFilters", () => {
-    it("is a fully-open filter — no dimension active, newest-first", () => {
+    it("is a fully-open filter, no dimension active, newest-first", () => {
         const f = emptyRunFilters();
         expect(f.statuses).toEqual([]);
         expect(f.sortDirection).toBe("desc");
@@ -54,23 +50,6 @@ describe("emptyRunFilters", () => {
     });
 });
 
-describe("isNeedsAttention", () => {
-    it("is true for exactly the attention set, order-insensitive", () => {
-        expect(isNeedsAttention([...NEEDS_ATTENTION_STATUSES])).toBe(true);
-        expect(isNeedsAttention([...NEEDS_ATTENTION_STATUSES].reverse())).toBe(true);
-    });
-
-    it("is exactly the failure sentinel (server resolves it to is_failure)", () => {
-        expect(NEEDS_ATTENTION_STATUSES).toEqual([FAILURE_STATUS_TOKEN]);
-    });
-
-    it("is false for a raw end reason or a different set", () => {
-        expect(isNeedsAttention(["failed"])).toBe(false);
-        expect(isNeedsAttention(["succeeded"])).toBe(false);
-        expect(isNeedsAttention([])).toBe(false);
-    });
-});
-
 describe("dimensionActive / activeDimensions", () => {
     it("detects each dimension independently", () => {
         expect(dimensionActive(base({ statuses: ["failed"] }), "status")).toBe(true);
@@ -125,25 +104,6 @@ describe("clearDimension", () => {
     });
 });
 
-describe("clearPopoverFilters", () => {
-    it("clears every popover dimension but keeps search and sort", () => {
-        const f = base({
-            search: "nightly",
-            sortDirection: "asc",
-            statuses: ["failed"],
-            taskName: "backup",
-            triggeredBy: "cron",
-            exitCode: "1",
-            retriesOnly: true,
-            createdAfter: "2026-01-01T00:00:00Z",
-        });
-        const cleared = clearPopoverFilters(f);
-        expect(activeFilterCount(cleared)).toBe(0);
-        expect(cleared.search).toBe("nightly");
-        expect(cleared.sortDirection).toBe("asc");
-    });
-});
-
 describe("humanizeStatus", () => {
     it("title-cases and de-snakes a status token", () => {
         expect(humanizeStatus("log_overflow")).toBe("Log overflow");
@@ -154,8 +114,8 @@ describe("humanizeStatus", () => {
 
 describe("statusChipLabel", () => {
     it("names a bucket when the selection matches one exactly", () => {
-        // The Failed bucket is the needs-attention set.
-        expect(statusChipLabel([...NEEDS_ATTENTION_STATUSES])).toBe("Failed");
+        // The Failed bucket is the failure sentinel.
+        expect(statusChipLabel([FAILURE_STATUS_TOKEN])).toBe("Failed");
         expect(statusChipLabel(["pending", "running"])).toBe("Running");
         expect(statusChipLabel(["succeeded"])).toBe("Succeeded");
     });
@@ -172,7 +132,7 @@ describe("statusChipLabel", () => {
 describe("STATUS_BUCKETS", () => {
     // The Failed bucket is the failure sentinel (resolved server-side to the
     // per-task is_failure classification), so the execution-failure reasons are
-    // not bucketed — they stay reachable via the popover's Advanced expander.
+    // not bucketed, they stay reachable via the popover's Advanced expander.
     const FAILURE_REASONS = [
         "failed",
         "crashed",
@@ -332,19 +292,3 @@ describe("exit-code expression", () => {
         expect(exitCodeChipLabel(" 137 ")).toBe("Exit 137");
     });
 });
-
-describe("exitCodePropChanged", () => {
-    it("is false when the committed value is unchanged (unrelated filters update)", () => {
-        expect(exitCodePropChanged("137", "137")).toBe(false);
-        expect(exitCodePropChanged(undefined, undefined)).toBe(false);
-    });
-
-    it("is true when the exit-code filter was cleared externally (chip removed)", () => {
-        expect(exitCodePropChanged("137", undefined)).toBe(true);
-    });
-
-    it("is true when the exit-code filter was set to a new committed value", () => {
-        expect(exitCodePropChanged(undefined, "200")).toBe(true);
-        expect(exitCodePropChanged("137", "200")).toBe(true);
-    });
-});

package/src/lib/components/dashboard/run-filters.ts

@@ -2,86 +2,51 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TRIGGERS, type Trigger } from "@runwisp/common";
-
-export type RunsListSortDirection = "asc" | "desc" | "";
+import { TRIGGER_LABELS } from "./run-helpers.js";
 
 /**
- * The single filter shape shared by the runs list, the filter popover, the
- * SSE-merge source, and the bulk selector. Every field beyond `search` and
- * `sortDirection` is an optional dimension applied server-side; the zero
- * value (`emptyRunFilters`) matches every run.
- *
- * `statuses` is a multi-select set joined to a comma-separated string only at
- * the two wire boundaries (the list query and the bulk selector). Time bounds
- * are absolute RFC3339 instants — presets resolve to `now − delta` at apply
- * time so a live SSE row created after the boundary keeps matching.
+ * The filter shared by the runs list, the filter popover, the SSE-merge source
+ * and the bulk selector. Time bounds are absolute RFC3339 instants, so a live
+ * SSE row created after a preset was applied keeps matching.
  */
 export interface RunsListFilters {
     search: string;
     statuses: string[];
-    sortDirection: RunsListSortDirection;
+    sortDirection: "asc" | "desc" | "";
     // Optional dimensions explicitly admit `undefined` so a dimension can be
     // cleared by reassignment (`{ ...f, x: undefined }`) under the project's
-    // exactOptionalPropertyTypes — a fresh object reference is what re-triggers
+    // exactOptionalPropertyTypes, a fresh object reference is what re-triggers
     // the parent's fetch effect through several levels of `bind:`.
     taskName?: string | undefined;
     createdAfter?: string | undefined;
     createdBefore?: string | undefined;
     triggeredBy?: string | undefined;
-    // A human exit-code expression — a bare code (`137`), a comparison (`>100`,
-    // `<=150`), or a space-separated combination (`>100 <150`). Normalized to an
-    // inclusive [min, max] range (`exitCodeRange`) at the wire boundary; the
-    // server only ever sees `exitCodeMin` / `exitCodeMax`.
+    // An exit-code expression such as `137`, `>100` or `>100 <150`; see
+    // parseExitCodeRange.
     exitCode?: string | undefined;
     retriesOnly?: boolean | undefined;
 }
 
-/** A fresh default filter — no dimensions active, newest-first. */
+/** A fresh default filter, no dimensions active, newest-first. */
 export function emptyRunFilters(): RunsListFilters {
     return { search: "", statuses: [], sortDirection: "desc" };
 }
 
 /**
- * Reserved `status` token the "Failed" browse filter sends instead of a fixed
- * end-reason list. The server (splitFailureToken in api_types.go) strips it and
- * matches on each run's persisted `isFailure` bit, so the browse filter agrees
- * with the attention badges, the failed stat, and notifications — all of which
- * follow the per-task `failures` policy. It is not a real status/end-reason, so
- * it OR-combines with the other buckets. Must match `failureStatusToken` in the
- * daemon.
+ * Reserved `status` token for the "Failed" filter. The daemon matches it on each
+ * run's `isFailure` bit (per-task `failures` policy) instead of a fixed
+ * end-reason list. Must match `failureStatusToken` in the daemon.
  */
 export const FAILURE_STATUS_TOKEN = "failure";
 
 /**
- * The status set backing the "Failed" browse filter and the one-click preset
- * that serves Prime Directive #1 — nothing silently fails. Just the failure
- * sentinel: the server resolves it to the per-task `isFailure` classification
- * rather than a fixed end-reason list.
- */
-export const NEEDS_ATTENTION_STATUSES: readonly string[] = [FAILURE_STATUS_TOKEN];
-
-/** True when `statuses` is exactly the needs-attention set (order-insensitive). */
-export function isNeedsAttention(statuses: string[]): boolean {
-    if (statuses.length !== NEEDS_ATTENTION_STATUSES.length) return false;
-    const set = new Set(statuses);
-    return NEEDS_ATTENTION_STATUSES.every((s) => set.has(s));
-}
-
-/**
- * Outcome buckets: the 14 individual run statuses collapsed into five
- * plain-language groups, so the common case is a five-item pick instead of a
- * flat checklist. Each bucket is purely a UI grouping over `statuses` — toggling
- * one adds/removes its members, and the popover's "Advanced" section still
- * exposes the individual statuses for surgical filters (e.g. only `timeout`).
- *
- * Every status appears in exactly one bucket; `Failed` is the needs-attention
- * set (Prime Directive #1). `dot` mirrors that group's color in
- * RUN_STATUS_CONFIG so the bucket reads at a glance.
+ * Outcome buckets: a UI grouping of the individual run statuses into five
+ * plain-language picks. The popover's "Advanced" section still exposes the
+ * individual statuses. `dot` mirrors the group's color in RUN_STATUS_CONFIG.
  */
 export interface StatusBucket {
     key: string;
     label: string;
-    /** Tailwind background class for the bucket's status dot. */
     dot: string;
     statuses: readonly string[];
 }
@@ -93,7 +58,7 @@ export const STATUS_BUCKETS: readonly StatusBucket[] = [
         key: "failed",
         label: "Failed",
         dot: "bg-danger-surface",
-        statuses: NEEDS_ATTENTION_STATUSES,
+        statuses: [FAILURE_STATUS_TOKEN],
     },
     {
         key: "skipped",
@@ -111,7 +76,6 @@ export const STATUS_BUCKETS: readonly StatusBucket[] = [
 
 export type BucketState = "on" | "partial" | "off";
 
-/** Whether none, some, or all of a bucket's statuses are currently selected. */
 export function bucketState(statuses: string[], bucket: StatusBucket): BucketState {
     const set = new Set(statuses);
     const present = bucket.statuses.filter((s) => set.has(s)).length;
@@ -138,7 +102,7 @@ function exactBucket(statuses: string[]): StatusBucket | undefined {
 
 /**
  * The popover-managed dimensions, in display (most→least useful) order.
- * `task` only ever applies on the cross-task /runs view — on a single task's
+ * `task` only ever applies on the cross-task /runs view, on a single task's
  * page the task name is the page scope (injected at fetch time), never a
  * popover-set filter, so it stays absent from those filters and is not counted.
  */
@@ -153,7 +117,6 @@ const DIMENSION_ORDER: FilterDimension[] = [
     "retries",
 ];
 
-/** Whether a single dimension is currently constraining the result set. */
 export function dimensionActive(f: RunsListFilters, dim: FilterDimension): boolean {
     switch (dim) {
         case "status":
@@ -171,17 +134,16 @@ export function dimensionActive(f: RunsListFilters, dim: FilterDimension): boole
     }
 }
 
-/** The active dimensions, in display order — drives the chip row. */
+/** The active dimensions, in display order, drives the chip row. */
 export function activeDimensions(f: RunsListFilters): FilterDimension[] {
     return DIMENSION_ORDER.filter((dim) => dimensionActive(f, dim));
 }
 
-/** How many dimensions are active — the count badge on the Filter button. */
+/** How many dimensions are active, the count badge on the Filter button. */
 export function activeFilterCount(f: RunsListFilters): number {
     return activeDimensions(f).length;
 }
 
-/** Reset one dimension, leaving the others (and search/sort) untouched. */
 export function clearDimension(f: RunsListFilters, dim: FilterDimension): RunsListFilters {
     switch (dim) {
         case "status":
@@ -199,23 +161,6 @@ export function clearDimension(f: RunsListFilters, dim: FilterDimension): RunsLi
     }
 }
 
-/**
- * Clear every popover dimension at once, preserving the header search and the
- * sort direction (those are separate toolbar controls, not popover state).
- */
-export function clearPopoverFilters(f: RunsListFilters): RunsListFilters {
-    return {
-        ...f,
-        statuses: [],
-        createdAfter: undefined,
-        createdBefore: undefined,
-        taskName: undefined,
-        triggeredBy: undefined,
-        exitCode: undefined,
-        retriesOnly: undefined,
-    };
-}
-
 /** Human label for a status value, e.g. `log_overflow` → "Log overflow". */
 export function humanizeStatus(status: string): string {
     if (!status) return status;
@@ -223,47 +168,20 @@ export function humanizeStatus(status: string): string {
     return spaced.charAt(0).toUpperCase() + spaced.slice(1);
 }
 
-/**
- * Descriptive label for a run's trigger source — fuller than the one-word row
- * badge (`formatTriggeredByLabel`) for the "cron"/"station"/"service"/"startup"
- * sources, where the extra words disambiguate (e.g. "REST API" vs a bare
- * "API"). "ui", "cli" and "hook" already read fine as their bare badge word,
- * so those three match `formatTriggeredByLabel` exactly.
- *
- * Note `cron` covers both on-time schedule firings and catch-up for missed
- * runs, and `startup` is specifically `run_on_start` (not catch-up).
- */
+/** Descriptive label for a run's trigger source (see {@link TRIGGER_LABELS}). */
 export function triggerDescription(trigger: string): string {
-    switch (trigger) {
-        case "cron":
-            return "Scheduled (cron)";
-        case "api":
-            return "REST API";
-        case "ui":
-            return "UI";
-        case "cli":
-            return "CLI";
-        case "station":
-            return "Control plane";
-        case "service":
-            return "Service auto-start";
-        case "startup":
-            return "On daemon start";
-        case "hook":
-            return "Hook";
-        default:
-            return humanizeStatus(trigger);
-    }
+    const known = TRIGGERS.find((t) => t === trigger);
+    return known ? TRIGGER_LABELS[known].long : humanizeStatus(trigger);
 }
 
 /**
  * The triggers offered in the filter dropdown. `station` is intentionally
- * excluded for now — control-plane runs still carry the `station` trigger, but
+ * excluded for now, control-plane runs still carry the `station` trigger, but
  * it isn't a selectable filter dimension.
  */
 export const FILTERABLE_TRIGGERS: readonly Trigger[] = TRIGGERS.filter((t) => t !== "station");
 
-/** Chip label for the status dimension — names a whole bucket when it matches. */
+/** Chip label for the status dimension, names a whole bucket when it matches. */
 export function statusChipLabel(statuses: string[]): string {
     const bucket = exactBucket(statuses);
     if (bucket) return bucket.label;
@@ -272,15 +190,6 @@ export function statusChipLabel(statuses: string[]): string {
     return `${String(statuses.length)} statuses`;
 }
 
-// --- Time helpers --------------------------------------------------------
-//
-// A bare calendar day (`YYYY-MM-DD` from a native date input) maps to a local
-// instant: the "from" edge is that day's 00:00, the "to" edge is its end
-// (23:59:59.999) so picking the same day for both bounds — or the one-click
-// "on day" shortcut — captures the whole day and round-trips back to the same
-// date in the inputs. Bounds are stored as absolute RFC3339 (UTC) instants, the
-// shape the list query and SSE-merge filter already expect.
-
 /** Parse `YYYY-MM-DD` into the local Date for that day, or null if malformed. */
 function localDay(dateStr: string): Date | null {
     const parts = dateStr.split("-");
@@ -328,14 +237,6 @@ export function isWholeDay(after?: string, before?: string): boolean {
     );
 }
 
-// --- Exit-code expression ------------------------------------------------
-//
-// The popover takes a free-form exit-code expression and normalizes it to an
-// inclusive integer [min, max] range — the shape the server gates on. Because
-// exit codes are integers, a strict comparison collapses to an inclusive
-// bound: `>100` is min 101, `<150` is max 149. Tokens combine (`>100 <150`),
-// and a bare number is an exact match (min = max = n).
-
 export interface ExitCodeRange {
     min?: number;
     max?: number;
@@ -344,10 +245,10 @@ export interface ExitCodeRange {
 const EXIT_CODE_TOKEN = /^(>=|<=|>|<)?(-?\d+)$/;
 
 /**
- * Parse an exit-code expression into an inclusive [min, max] range. Returns
- * `valid: false` if any token is unparseable, so the UI can flag a typo
- * instead of silently applying half of it. An empty expression is valid with
- * no bounds (no constraint).
+ * Parse an exit-code expression into the inclusive integer range the server
+ * filters on: `>100` is min 101, `<150` is max 149, a bare number is an exact
+ * match, and tokens combine. Any unparseable token makes the whole expression
+ * invalid so the UI can flag the typo. An empty expression is valid and unbounded.
  */
 export function parseExitCodeRange(expr: string): { range: ExitCodeRange; valid: boolean } {
     const range: ExitCodeRange = {};
@@ -386,13 +287,12 @@ export function exitCodeRange(expr: string | undefined): ExitCodeRange {
     return valid ? range : {};
 }
 
-/** True when the expression resolves to at least one bound (a real filter). */
 export function exitCodeRangeActive(expr: string | undefined): boolean {
     const { min, max } = exitCodeRange(expr);
     return min !== undefined || max !== undefined;
 }
 
-/** True when the expression is empty or fully parseable — drives input validation. */
+/** True when the expression is empty or fully parseable, drives input validation. */
 export function isExitCodeExprValid(expr: string): boolean {
     return parseExitCodeRange(expr).valid;
 }
@@ -401,18 +301,3 @@ export function isExitCodeExprValid(expr: string): boolean {
 export function exitCodeChipLabel(expr: string | undefined): string {
     return `Exit ${(expr ?? "").trim()}`;
 }
-
-/**
- * Whether the popover's exit-code text buffer must resync to the `filters`
- * prop. True only when the committed `exitCode` value actually moved since
- * the buffer last matched it — e.g. the "Exit code" chip was removed, or
- * "clear filters" ran elsewhere. An unrelated filters update (any other
- * dimension) leaves `exitCode` untouched and must not clobber in-progress
- * typing in the still-open popover.
- */
-export function exitCodePropChanged(
-    previous: string | undefined,
-    next: string | undefined,
-): boolean {
-    return previous !== next;
-}

package/src/lib/components/dashboard/run-helpers.test.ts

@@ -2,23 +2,26 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { RUN_STATUSES } from "@runwisp/common";
 import {
     runDuration,
     runStartDelay,
     runVerdict,
     formatTriggeredByLabel,
     runRetryLabel,
+    runUsageLabel,
     instanceSuffix,
+    runLogDownloadUrl,
 } from "./run-helpers.js";
 
-describe("runVerdict", () => {
-    it("covers every run status", () => {
-        for (const status of RUN_STATUSES) {
-            expect(runVerdict(status).verb, status).toBeTruthy();
-        }
+describe("runLogDownloadUrl", () => {
+    it("points at the daemon's raw log route", () => {
+        expect(runLogDownloadUrl("01J0000000000000000000000A")).toBe(
+            "/api/runs/01J0000000000000000000000A/log/raw",
+        );
     });
+});
 
+describe("runVerdict", () => {
     it("phrases a timed outcome so a duration reads after it", () => {
         expect(runVerdict("succeeded")).toEqual({ verb: "succeeded in", timed: true });
         expect(runVerdict("failed")).toEqual({ verb: "failed after", timed: true });
@@ -116,6 +119,22 @@ describe("formatTriggeredByLabel", () => {
     });
 });
 
+describe("runUsageLabel", () => {
+    it("is undefined for an unmeasured run", () => {
+        expect(runUsageLabel({})).toBeUndefined();
+    });
+
+    it("joins peak memory and CPU time", () => {
+        expect(runUsageLabel({ peakMemoryBytes: 48 * 1024 * 1024, cpuTimeMs: 1500 })).toBe(
+            "peak 48 MB · CPU 1s",
+        );
+    });
+
+    it("shows whichever was measured", () => {
+        expect(runUsageLabel({ cpuTimeMs: 0 })).toBe("CPU 0ms");
+    });
+});
+
 describe("runRetryLabel", () => {
     it("returns undefined for a first attempt that is not a retry", () => {
         expect(runRetryLabel({ retryAttempt: 0 })).toBeUndefined();