@runwisp/ui 1.5.0 → 1.7.0

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

@@ -2,30 +2,57 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Run } from "@runwisp/common";
 import {
     runDuration,
     runStartDelay,
-    runVerdict,
+    RUN_VERDICTS,
+    runEndMarker,
+    runRowReadout,
+    highlightParts,
     formatTriggeredByLabel,
     runRetryLabel,
     runUsageLabel,
+    runUsageScale,
+    usageLevel,
     instanceSuffix,
+    runLogDownloadUrl,
 } from "./run-helpers.js";
 
-describe("runVerdict", () => {
+describe("runLogDownloadUrl", () => {
+    it("points at the daemon's raw log route", () => {
+        expect(runLogDownloadUrl("01J0000000000000000000000A")).toBe(
+            "/api/runs/01J0000000000000000000000A/log/raw",
+        );
+    });
+});
+
+describe("runEndMarker", () => {
+    it("warns only for ends the operator or daemon caused", () => {
+        expect(runEndMarker("stopped")).toEqual({
+            label: "run stopped by operator",
+            tone: "warn",
+        });
+        expect(runEndMarker("daemon_stopped").tone).toBe("warn");
+        expect(runEndMarker("timeout").label).toBe("run timed out");
+        expect(runEndMarker("failed")).toEqual({ label: "end of output", tone: "muted" });
+    });
+});
+
+describe("RUN_VERDICTS", () => {
     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 });
+        expect(RUN_VERDICTS.succeeded).toEqual({ verb: "succeeded in", timed: true });
+        expect(RUN_VERDICTS.failed).toEqual({ verb: "failed after", timed: true });
     });
 
     it("marks statuses that never produced a duration as untimed", () => {
         // These end without ever running, so the caller renders the verb alone
         // rather than "skipped after —".
-        expect(runVerdict("missed").timed).toBe(false);
-        expect(runVerdict("skipped").timed).toBe(false);
-        expect(runVerdict("dst_skipped").timed).toBe(false);
-        expect(runVerdict("queue_full").timed).toBe(false);
-        expect(runVerdict("pending").timed).toBe(false);
+        expect(RUN_VERDICTS.missed.timed).toBe(false);
+        expect(RUN_VERDICTS.skipped.timed).toBe(false);
+        expect(RUN_VERDICTS.dst_skipped.timed).toBe(false);
+        expect(RUN_VERDICTS.queue_full.timed).toBe(false);
+        expect(RUN_VERDICTS.pending.timed).toBe(false);
     });
 });
 
@@ -115,9 +142,9 @@ describe("runUsageLabel", () => {
         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("joins CPU time and memory, never saying peak", () => {
+        expect(runUsageLabel({ peakMemoryBytes: 48 * 1024 * 1024, cpuTimeMs: 112_000 })).toBe(
+            "CPU 1m 52s · RAM 48 MB",
         );
     });
 
@@ -158,3 +185,95 @@ describe("instanceSuffix", () => {
         expect(instanceSuffix(2, 3)).toBe("#3");
     });
 });
+
+describe("runRowReadout", () => {
+    const ended = { startedAt: "2026-01-01T00:00:00Z", endedAt: "2026-01-01T00:00:02Z" };
+
+    it("shows live, queued and the exit code of a failure", () => {
+        expect(runRowReadout({ ...ended, status: "running", exitCode: 0 }, "running")).toBe("live");
+        expect(runRowReadout({ ...ended, status: "pending", exitCode: 0 }, "pending")).toBe(
+            "queued",
+        );
+        expect(runRowReadout({ ...ended, status: "ended", exitCode: 3 }, "failed")).toBe("exit 3");
+    });
+
+    it("falls back to the duration, or a dash when it never started", () => {
+        expect(runRowReadout({ ...ended, status: "ended", exitCode: 0 }, "succeeded")).toBe("2s");
+        expect(runRowReadout({ status: "ended", exitCode: 0 }, "missed")).toBe("—");
+    });
+});
+
+describe("highlightParts", () => {
+    it("returns the whole line when nothing matches", () => {
+        expect(highlightParts("hello", "zzz")).toEqual({ before: "hello", match: "", after: "" });
+        expect(highlightParts("hello", "  ")).toEqual({ before: "hello", match: "", after: "" });
+    });
+
+    it("splits around a case-insensitive match", () => {
+        expect(highlightParts("an ERROR here", "error")).toEqual({
+            before: "an ",
+            match: "ERROR",
+            after: " here",
+        });
+    });
+
+    it("windows a long lead-in with an ellipsis", () => {
+        const parts = highlightParts("x".repeat(40) + "needle", "needle");
+        expect(parts.before).toBe("…" + "x".repeat(14));
+        expect(parts.match).toBe("needle");
+    });
+});
+
+describe("runUsageScale", () => {
+    const run = (
+        cpuTimeMs?: number,
+        peakMemoryBytes?: number,
+        status: Run["status"] = "ended",
+    ) => ({
+        status,
+        ...(cpuTimeMs === undefined ? {} : { cpuTimeMs }),
+        ...(peakMemoryBytes === undefined ? {} : { peakMemoryBytes }),
+    });
+
+    it("is undefined when no finished run was measured", () => {
+        expect(runUsageScale([])).toBeUndefined();
+        expect(runUsageScale([run(5, 10, "running"), run(undefined, 10)])).toBeUndefined();
+    });
+
+    it("scales to the largest run and takes the median as usual", () => {
+        expect(runUsageScale([run(100, 1400), run(110, 2900), run(30, 640), run(1, 1)])).toEqual({
+            max: { cpu: 110, ram: 2900 },
+            usual: { cpu: 100, ram: 1400 },
+        });
+    });
+
+    it("leaves out live and unmeasured runs", () => {
+        expect(runUsageScale([run(10, 10), run(999, 999, "running"), run(undefined, 999)])).toEqual(
+            {
+                max: { cpu: 10, ram: 10 },
+                usual: { cpu: 10, ram: 10 },
+            },
+        );
+    });
+});
+
+describe("usageLevel", () => {
+    it("is 0 as usual, 1 from 1.5x, 2 from twice the usual run", () => {
+        expect(usageLevel(1400, 1400, "cpu")).toBe(0);
+        expect(usageLevel(2099, 1400, "cpu")).toBe(0);
+        expect(usageLevel(2100, 1400, "cpu")).toBe(1);
+        expect(usageLevel(2799, 1400, "cpu")).toBe(1);
+        expect(usageLevel(2800, 1400, "cpu")).toBe(2);
+        expect(usageLevel(10, 1400, "cpu")).toBe(0);
+    });
+
+    it("judges a zero or tiny usual run against a floor", () => {
+        // A mostly idle task (median CPU 0) that burned 30s of CPU.
+        expect(usageLevel(30_000, 0, "cpu")).toBe(2);
+        expect(usageLevel(1, 0, "cpu")).toBe(0);
+        expect(usageLevel(3, 1, "cpu")).toBe(0);
+        // 64 MiB against an idle task's 1 MiB stands out; 8 MiB doesn't.
+        expect(usageLevel(64 * 1024 * 1024, 1024 * 1024, "ram")).toBe(2);
+        expect(usageLevel(8 * 1024 * 1024, 1024 * 1024, "ram")).toBe(0);
+    });
+});

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

@@ -1,26 +1,18 @@
 // SPDX-FileCopyrightText: PoppyCake, s.r.o.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Run, RunStatus } from "@runwisp/common";
+import type { APIPaths, Run, RunStatus, Trigger } from "@runwisp/common";
 import { formatBytes, formatDuration } from "../../utils/format.js";
 
 export interface RunVerdict {
     /** Verb phrase for the outcome, ending in its preposition when `timed`. */
     verb: string;
-    /**
-     * Whether the phrase expects a duration after it. False for statuses that
-     * never produced one (nothing ran, or nothing has yet), so the caller
-     * renders the verb alone rather than "skipped after —".
-     */
+    /** Whether a duration follows the verb; false when nothing ran yet. */
     timed: boolean;
 }
 
-/**
- * The run's outcome as a verb phrase, so a detail view can state it as one
- * sentence ("succeeded in 933ms") instead of a status badge competing with a
- * separate duration readout for the same glance.
- */
-const RUN_VERDICTS: Record<RunStatus, RunVerdict> = {
+// The run's outcome as a verb phrase, read as one sentence: "succeeded in 933ms".
+export const RUN_VERDICTS: Record<RunStatus, RunVerdict> = {
     succeeded: { verb: "succeeded in", timed: true },
     failed: { verb: "failed after", timed: true },
     crashed: { verb: "crashed after", timed: true },
@@ -39,8 +31,21 @@ const RUN_VERDICTS: Record<RunStatus, RunVerdict> = {
     queue_full: { verb: "skipped", timed: false },
 };
 
-export function runVerdict(status: RunStatus): RunVerdict {
-    return RUN_VERDICTS[status];
+export interface RunEndMarker {
+    label: string;
+    tone: "muted" | "warn";
+}
+
+// The line closing a run's console output; only abnormal ends are worth a warning tone.
+const RUN_END_MARKERS: Partial<Record<RunStatus, RunEndMarker>> = {
+    stopped: { label: "run stopped by operator", tone: "warn" },
+    daemon_stopped: { label: "daemon stopped mid-run", tone: "warn" },
+    timeout: { label: "run timed out", tone: "warn" },
+};
+const DEFAULT_END_MARKER: RunEndMarker = { label: "end of output", tone: "muted" };
+
+export function runEndMarker(status: RunStatus): RunEndMarker {
+    return RUN_END_MARKERS[status] ?? DEFAULT_END_MARKER;
 }
 
 export function runDuration(
@@ -54,12 +59,8 @@ export function runDuration(
 }
 
 /**
- * Gap between when a run was scheduled (`createdAt`, the cron tick) and when
- * it actually started (`startedAt`), formatted — or undefined when the two are
- * within a second of each other. This is the visible face of `jitter`: a
- * jittered run is created at its tick but starts later inside the window, and
- * this is by how much. It also surfaces queue-wait, since a queued run is
- * created when it joins the line and started when the line clears.
+ * How long a run waited between `createdAt` and `startedAt` (jitter or queue
+ * wait), or undefined when it started within a second.
  */
 export function runStartDelay(run: Pick<Run, "createdAt" | "startedAt">): string | undefined {
     if (!run.startedAt) return undefined;
@@ -68,14 +69,7 @@ export function runStartDelay(run: Pick<Run, "createdAt" | "startedAt">): string
     return formatDuration(delay);
 }
 
-/**
- * Display suffix for a run's instance slot. A service configured with more than
- * one instance gets a 1-based suffix (`#1`, `#2`, …) on every one of its runs;
- * a single-instance task (or any non-service, where `instanceCount` is 1)
- * returns an empty string so the bare task name is shown. `instanceIndex` is
- * the stored 0-based slot; `instanceCount` is the task's currently configured
- * instance count.
- */
+/** 1-based `#N` suffix for a multi-instance service run, else "". */
 export function instanceSuffix(instanceIndex: number, instanceCount: number): string {
     if (instanceCount > 1) {
         return `#${String(instanceIndex + 1)}`;
@@ -83,23 +77,32 @@ export function instanceSuffix(instanceIndex: number, instanceCount: number): st
     return "";
 }
 
+// Typed against the generated paths so a route rename fails the build.
+const RAW_LOG_PATH: keyof APIPaths = "/api/runs/{runId}/log/raw";
+
+/** The full log of a run as one plain-text download. */
+export function runLogDownloadUrl(runId: string): string {
+    return RAW_LOG_PATH.replace("{runId}", encodeURIComponent(runId));
+}
+
+/** Labels per trigger source: `short` for the row badge, `long` for descriptions. */
+export const TRIGGER_LABELS: Record<Trigger, { short: string; long: string }> = {
+    cron: { short: "Cron", long: "Scheduled (cron)" },
+    api: { short: "API", long: "REST API" },
+    ui: { short: "UI", long: "UI" },
+    cli: { short: "CLI", long: "CLI" },
+    station: { short: "Station", long: "Control plane" },
+    service: { short: "Service", long: "Service auto-start" },
+    startup: { short: "Startup", long: "On daemon start" },
+    hook: { short: "Hook", long: "Hook" },
+};
+
 /** Human label for why a run fired (the `triggeredBy` source). */
 export function formatTriggeredByLabel(triggeredBy: Run["triggeredBy"]): string {
-    if (triggeredBy === "api") return "API";
-    if (triggeredBy === "ui") return "UI";
-    if (triggeredBy === "cli") return "CLI";
-    if (triggeredBy === "cron") return "Cron";
-    if (triggeredBy === "service") return "Service";
-    if (triggeredBy === "startup") return "Startup";
-    if (triggeredBy === "hook") return "Hook";
-    return "Station";
+    return TRIGGER_LABELS[triggeredBy].short;
 }
 
-/**
- * "retry #N" label when a run is a retry of an earlier one, else undefined.
- * A run is a retry if it carries a positive attempt number or points back at
- * the run it re-attempts.
- */
+/** "retry #N" when the run re-attempts an earlier one, else undefined. */
 export function runRetryLabel(run: Pick<Run, "retryAttempt" | "retryOfRunId">): string | undefined {
     if (run.retryAttempt > 0 || run.retryOfRunId) {
         return `retry #${String(run.retryAttempt)}`;
@@ -108,16 +111,82 @@ export function runRetryLabel(run: Pick<Run, "retryAttempt" | "retryOfRunId">):
 }
 
 /**
- * "peak 48 MB · CPU 1s" for a run whose resources were measured (shell runs
- * only), else undefined.
+ * "CPU 1m 52s · RAM 48 MB" for a run whose resources were measured (shell
+ * runs only), else undefined. CPU is the CPU time the run used, RAM the most
+ * memory it held.
  */
 export function runUsageLabel(run: Pick<Run, "peakMemoryBytes" | "cpuTimeMs">): string | undefined {
     const parts: string[] = [];
-    if (run.peakMemoryBytes !== undefined) parts.push("peak " + formatBytes(run.peakMemoryBytes));
     if (run.cpuTimeMs !== undefined) parts.push("CPU " + formatDuration(run.cpuTimeMs));
+    if (run.peakMemoryBytes !== undefined) parts.push("RAM " + formatBytes(run.peakMemoryBytes));
     return parts.length > 0 ? parts.join(" · ") : undefined;
 }
 
+/** CPU time (ms) and peak memory (bytes) of one run, or of a task's typical run. */
+export interface RunUsageAmounts {
+    cpu: number;
+    ram: number;
+}
+
+/**
+ * How a task's runs compare: `max` is its largest run (the full length of a
+ * usage bar), `usual` the median run (what "normal for this task" means).
+ */
+export interface RunUsageScale {
+    max: RunUsageAmounts;
+    usual: RunUsageAmounts;
+}
+
+/** A finished run's measured usage, or undefined when it wasn't measured. */
+export function runUsageAmounts(
+    run: Pick<Run, "status" | "cpuTimeMs" | "peakMemoryBytes">,
+): RunUsageAmounts | undefined {
+    if (run.status !== "ended") return undefined;
+    if (run.cpuTimeMs === undefined || run.peakMemoryBytes === undefined) return undefined;
+    return { cpu: run.cpuTimeMs, ram: run.peakMemoryBytes };
+}
+
+function median(values: number[]): number {
+    const sorted = values.toSorted((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)] ?? 0;
+}
+
+/** The scale for a task's usage bars, over the measured runs given. */
+export function runUsageScale(
+    runs: readonly Pick<Run, "status" | "cpuTimeMs" | "peakMemoryBytes">[],
+): RunUsageScale | undefined {
+    const amounts = runs.flatMap((run) => runUsageAmounts(run) ?? []);
+    if (amounts.length === 0) return undefined;
+    const cpu = amounts.map((a) => a.cpu);
+    const ram = amounts.map((a) => a.ram);
+    return {
+        max: { cpu: Math.max(...cpu), ram: Math.max(...ram) },
+        usual: { cpu: median(cpu), ram: median(ram) },
+    };
+}
+
+/**
+ * The least a usual run counts as using, so a tiny or zero baseline (a mostly
+ * idle task's median CPU time is often 0) doesn't hide a run that burns real
+ * CPU or memory, nor flag 3ms against 1ms. CPU time in ms, memory in bytes.
+ */
+const USAGE_FLOOR: RunUsageAmounts = { cpu: 1000, ram: 16 * 1024 * 1024 };
+
+/**
+ * How unusual a run's amount is for its task: 0 about as usual, 1 at 1.5×
+ * the usual run, 2 at twice it or more. A task that always uses the same
+ * amount stays at 0, however large that amount is. The usual run counts as
+ * at least USAGE_FLOOR for its kind.
+ */
+export function usageLevel(value: number, usual: number, kind: keyof RunUsageAmounts): 0 | 1 | 2 {
+    const baseline = Math.max(usual, USAGE_FLOOR[kind]);
+    if (baseline <= 0) return 0;
+    const ratio = value / baseline;
+    if (ratio >= 2) return 2;
+    if (ratio >= 1.5) return 1;
+    return 0;
+}
+
 /**
  * Monotonic position of a run's status in its lifecycle. Used to reject stale
  * updates (e.g. a `pending` HTTP response arriving after an SSE already
@@ -128,3 +197,40 @@ export function runPhaseOrder(status: string): number {
     if (status === "running") return 1;
     return 2;
 }
+
+/** Right-hand mono readout of a run row: live / queued / exit N / duration. */
+export function runRowReadout(
+    run: Pick<Run, "status" | "exitCode" | "startedAt" | "endedAt">,
+    displayed: RunStatus,
+): string {
+    if (run.status === "running") return "live";
+    if (run.status === "pending") return "queued";
+    if (displayed === "failed" || displayed === "crashed") return "exit " + String(run.exitCode);
+    return runDuration(run) ?? "—";
+}
+
+export interface HighlightParts {
+    before: string;
+    match: string;
+    after: string;
+}
+
+/**
+ * Split an output line into [before, match, after] around the first
+ * occurrence of the query, windowed to keep the match in view. Plain strings,
+ * so rendering them as text never lets untrusted HTML reach the DOM.
+ */
+export function highlightParts(text: string, query: string): HighlightParts {
+    const q = query.trim();
+    const idx = q ? text.toLowerCase().indexOf(q.toLowerCase()) : -1;
+    if (idx === -1) return { before: text, match: "", after: "" };
+    const start = Math.max(0, idx - 14);
+    const lead = start > 0 ? "…" : "";
+    const windowed = text.slice(start);
+    const fi = windowed.toLowerCase().indexOf(q.toLowerCase());
+    return {
+        before: lead + windowed.slice(0, fi),
+        match: windowed.slice(fi, fi + q.length),
+        after: windowed.slice(fi + q.length),
+    };
+}

package/src/lib/components/dashboard/status-config.ts

@@ -23,7 +23,14 @@ interface RunStatusConfig {
     color: string;
     bg: string;
     dot: string;
+    /** `dot` without the running pulse, for static markers (spines, filter swatches). */
+    solidDot: string;
     badge: string;
+    /**
+     * Accent colour for statuses that mean "something to triage", or undefined.
+     * A deliberate stop or a skip is not an alarm, and success least of all.
+     */
+    alarm: string | undefined;
     /** One-sentence explanation of what this status means, for tooltips. */
     description: string;
 }
@@ -34,19 +41,25 @@ const DANGER = {
     color: "text-danger-surface",
     bg: "bg-danger-soft",
     dot: "bg-danger-surface",
+    solidDot: "bg-danger-surface",
     badge: "bg-danger-soft text-danger-soft-text",
+    alarm: "var(--color-danger-surface)",
 };
 const WARNING = {
     color: "text-warning-surface",
     bg: "bg-warning-soft",
     dot: "bg-warning-surface",
+    solidDot: "bg-warning-surface",
     badge: "bg-warning-soft text-warning-soft-text",
+    alarm: "var(--color-warning-surface)",
 };
 const NEUTRAL = {
     color: "text-on-surface-muted",
     bg: "bg-surface-sunken",
     dot: "bg-on-surface-faint",
+    solidDot: "bg-on-surface-faint",
     badge: "bg-surface-sunken text-on-surface",
+    alarm: undefined,
 };
 
 export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
@@ -55,7 +68,9 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         color: "text-info-surface",
         bg: "bg-info-soft",
         dot: "bg-info-surface animate-pulse",
+        solidDot: "bg-info-surface",
         badge: "bg-info-soft text-info-soft-text",
+        alarm: undefined,
         description: "This run is executing right now.",
     },
     succeeded: {
@@ -63,7 +78,9 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         color: "text-success-surface",
         bg: "bg-success-soft",
         dot: "bg-success-surface",
+        solidDot: "bg-success-surface",
         badge: "bg-success-soft text-success-soft-text",
+        alarm: undefined,
         description: "The run finished with exit code 0 - everything OK.",
     },
     failed: {
@@ -79,6 +96,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
     },
     stopped: {
         ...WARNING,
+        alarm: undefined,
         icon: CircleStop,
         description: "A human or an external script manually stopped this run before it finished.",
     },

package/src/lib/components/dashboard/types.ts

@@ -7,3 +7,9 @@ export interface DaemonStats {
     activeTasks: number;
     successRate: number;
 }
+
+/** A single output-search hit surfaced under its run in the history rail. */
+export interface RunOutputMatch {
+    line: number;
+    text: string;
+}

package/src/lib/components/data-grid-selection.ts

@@ -1,14 +1,6 @@
 // SPDX-FileCopyrightText: PoppyCake, s.r.o.
 // SPDX-License-Identifier: Apache-2.0
 
-// DataGrid's header checkbox (checked / indeterminate / unchecked) must
-// reflect which rows on the current page are ACTUALLY selected, not merely
-// how many rows are selected. A bare count comparison is wrong the moment
-// `selectedRows` holds a different set of rows than `pagedRows` but happens
-// to be the same size — e.g. rows selected on a page the grid has since
-// paged/filtered away from. Extracted so the membership check is unit
-// testable without a component-render harness.
-
 export interface SelectionState {
     allSelected: boolean;
     someSelected: boolean;
@@ -17,7 +9,8 @@ export interface SelectionState {
 /**
  * Header checkbox state for `pagedRows`: fully checked only when every row
  * currently on the page is selected, indeterminate when some (but not all)
- * of them are. Matches rows by `rowKey`, not by array position or count.
+ * of them are. Matches rows by `rowKey`, not by count: the selection can
+ * hold rows from a page the grid has since moved away from.
  */
 export function selectionState<T>(
     pagedRows: readonly T[],

package/src/lib/components/filter-spec.ts

@@ -3,7 +3,7 @@
 
 // Declarative filter spec. A `FilterField[]` + one bound `FilterValues` object
 // drives <FilterBar>, the client engine (`applyFilters`), and the URL sync
-// helper — the same way DataGrid's `Column[]` drives the table. Add a field
+// helper, the same way DataGrid's `Column[]` drives the table. Add a field
 // type here, and every table that adopts it renders identically.
 
 import type { SelectOption } from "./Select.svelte";
@@ -44,7 +44,7 @@ export type FilterField =
           primary?: boolean;
       };
 
-// All values are strings — DOM inputs are string-valued and URL params are
+// All values are strings, DOM inputs are string-valued and URL params are
 // strings; the client engine coerces (e.g. Number()) where a field needs it.
 export type FilterValues = Record<string, string>;
 
@@ -65,7 +65,7 @@ export function isBlank(v: string | undefined): boolean {
     return !v || v === "all";
 }
 
-// Which value keys a field owns — daterange owns two, everything else one.
+// Which value keys a field owns, daterange owns two, everything else one.
 // Used by chips, active-state detection, clear, and URL (de)serialization so
 // none of them has to special-case the range type.
 export function fieldKeys(field: FilterField): string[] {

package/src/lib/index.ts

@@ -24,7 +24,7 @@ export { default as FormField } from "./components/FormField.svelte";
 export { default as Input } from "./components/Input.svelte";
 export { default as Radio } from "./components/Radio.svelte";
 export { default as RadioGroup } from "./components/RadioGroup.svelte";
-export { default as Select } from "./components/Select.svelte";
+export { default as Select, type SelectOption } from "./components/Select.svelte";
 export { default as Textarea } from "./components/Textarea.svelte";
 export { default as TimezoneSelect } from "./components/TimezoneSelect.svelte";
 export { default as Toggle } from "./components/Toggle.svelte";
@@ -86,14 +86,16 @@ export type { FetchLogsFn, LogEvent, LogSlice } from "./log-console/types.js";
 export { default as RunDetailPanel } from "./components/dashboard/RunDetailPanel.svelte";
 export { default as RunsList } from "./components/dashboard/RunsList.svelte";
 export { default as RunFilterPopover } from "./components/dashboard/RunFilterPopover.svelte";
-export type { RunOutputMatch } from "./components/dashboard/RunsList.svelte";
+export type { RunOutputMatch } from "./components/dashboard/types.js";
 export {
     activeFilterCount,
     emptyRunFilters,
     FAILURE_STATUS_TOKEN,
     humanizeStatus,
     exitCodeRange,
+    runFilterParams,
     type ExitCodeRange,
+    type RunFilterParams,
     type RunsListFilters,
 } from "./components/dashboard/run-filters.js";
 export { RUN_STATUS_CONFIG } from "./components/dashboard/status-config.js";
@@ -102,6 +104,10 @@ export {
     runPhaseOrder,
     formatTriggeredByLabel,
     instanceSuffix,
+    runUsageLabel,
+    runUsageScale,
+    usageLevel,
+    type RunUsageScale,
 } from "./components/dashboard/run-helpers.js";
 export { humanizeCron } from "./components/dashboard/cron-format.js";
 export type { DaemonStats } from "./components/dashboard/types.js";
@@ -110,14 +116,19 @@ export { toast } from "./utils/toast.svelte.js";
 export { extractErrorMessage } from "./utils/error.js";
 export {
     formatBytes,
+    formatDayMonth,
+    formatRelativeCompact,
     formatRelativeTime,
     formatRelativeTimeWithAbsolute,
+    type RelativeTimeOptions,
     formatDuration,
     formatFullDateTime,
 } from "./utils/format.js";
 export { formatShortId } from "./utils/id.js";
 export { debounce } from "./utils/debounce.js";
+export { isTypingTarget } from "./utils/typing-target.js";
 export { TickingNow } from "./utils/ticking-now.svelte.js";
 export { CopyFeedback, copyText } from "./utils/clipboard.svelte.js";
 export { RunMotion } from "./utils/run-motion.js";
 export { arrival, leave, shift } from "./actions/row-motion.js";
+export { foldToFit, foldUntilFits, type FoldToFitOptions } from "./actions/fold-to-fit.js";

package/src/lib/log-console/AnsiLine.svelte

@@ -0,0 +1,12 @@
+<!-- SPDX-FileCopyrightText: PoppyCake, s.r.o. -->
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+
+<script lang="ts">
+    import { ansiLineToHtml } from "./ansi.js";
+
+    let { text }: { text: string } = $props();
+</script>
+
+<!-- ansiLineToHtml sanitises its input, which is what makes @html safe here. -->
+<!-- eslint-disable-next-line svelte/no-at-html-tags -->
+<span class="whitespace-pre">{@html ansiLineToHtml(text)}</span>