@runwisp/ui 0.16.0 → 1.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@runwisp/ui",
   "description": "Svelte 5 UI component library for RunWisp dashboards and admin interfaces.",
-  "version": "0.16.0",
+  "version": "1.0.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -49,8 +49,8 @@
   "devDependencies": {
     "@chromatic-com/storybook": "^5.2.1",
     "@eslint/js": "^10.0.1",
-    "@runwisp/eslint-config": "0.16.0",
-    "@runwisp/typescript-config": "0.16.0",
+    "@runwisp/eslint-config": "1.0.0",
+    "@runwisp/typescript-config": "1.0.0",
     "@storybook/addon-a11y": "^10.5.5",
     "@storybook/addon-docs": "^10.5.5",
     "@storybook/addon-svelte-csf": "^5.1.2",
@@ -93,7 +93,7 @@
     "@fontsource-variable/geist-mono": "^5.3.0",
     "@fontsource/tasa-orbiter": "^5.3.0",
     "@lucide/svelte": "^1.28.0",
-    "@runwisp/common": "0.16.0",
+    "@runwisp/common": "1.0.0",
     "@tanstack/svelte-virtual": "^3.13.35",
     "ansi-to-html": "^0.7.2",
     "cron-parser": "^5.7.0",

package/src/lib/actions/focusTrap.ts

@@ -37,7 +37,7 @@ export function resolveTrapFocusTarget<T>(
 ): T | null {
     if (event.key !== "Tab" || focusable.length === 0) return null;
     const first = focusable[0];
-    const last = focusable[focusable.length - 1];
+    const last = focusable.at(-1);
     if (first === undefined || last === undefined) return null;
 
     if (event.shiftKey && active === first) return last;

package/src/lib/components/DataGrid.svelte

@@ -292,7 +292,7 @@
                         </td>
                     </tr>
                 {:else}
-                    {#each pagedData as row, idx (idx)}
+                    {#each pagedData as row, idx (row[rowKey])}
                         <tr
                             class="
 							    border-b border-outline last:border-b-0

package/src/lib/components/LogConsole.svelte

@@ -168,28 +168,56 @@
         return Math.max(1, Math.ceil(visibleColumns(text) / cols));
     }
 
+    // Measures wrapped row counts for exactly the lines in [min, max] and bumps
+    // rowCountVersion if anything changed. Called directly wherever new line
+    // text lands in the cache (streamed append, on-demand backfill), each of
+    // which already knows the touched range from LogCache's merge result — so
+    // a single appended line costs O(1) here instead of re-walking the whole
+    // (up to 50k-line) cache. Plain function, not an $effect: reads/writes
+    // rowCounts and cache.lines by key, never by iterating the map.
+    function measureRange(min: number, max: number) {
+        if (!wrap || min > max) return;
+        let changed = false;
+        for (let num = min; num <= max; num++) {
+            const r = wrappedRowsFor(cache.lines.get(num));
+            if (rowCounts.get(num) !== r) {
+                rowCounts.set(num, r);
+                changed = true;
+            }
+        }
+        if (changed) rowCountVersion++;
+    }
+
     // Line-text white-space model: wrapped lines break anywhere (so a long
     // token wraps mid-word the way a terminal would), unwrapped lines stay on
     // one horizontal-scrolling row.
     let lineTextClass = $derived(wrap ? "break-anywhere whitespace-pre-wrap" : "whitespace-pre");
 
-    // Recompute row counts for every loaded line whenever wrapping is on and
-    // either the cache or the available column width moves. Pruned lines keep
-    // their last-computed count so scroll geometry stays stable.
+    // Full remeasure of every loaded line, needed only when wrapping turns on
+    // or the available column width changes (wrap width affects every line's
+    // row count, so there's no way to scope that to a range). Line
+    // appends/backfills are measured incrementally at their call sites via
+    // measureRange instead — reading `cache.lines` in this effect's tracked
+    // scope would resubscribe it to the SvelteMap's shared version signal and
+    // re-run this full O(n) walk on every single appended line. `untrack`
+    // (same pattern as the fetch/prune effects below) keeps that read out of
+    // the dependency set, so only `wrap`/`availableColumns` retrigger this.
+    // Pruned lines keep their last-computed count so scroll geometry stays
+    // stable.
     $effect(() => {
         if (!wrap) return;
-        const lines = cache.lines;
         void availableColumns;
-        let changed = false;
-        for (const [num, text] of lines) {
-            const r = wrappedRowsFor(text);
-            const prev = rowCounts.get(num);
-            if (prev !== r) {
-                rowCounts.set(num, r);
-                changed = true;
+        untrack(() => {
+            let changed = false;
+            for (const [num, text] of cache.lines) {
+                const r = wrappedRowsFor(text);
+                if (rowCounts.get(num) !== r) {
+                    rowCounts.set(num, r);
+                    changed = true;
+                }
             }
-        }
-        if (changed) rowCountVersion++;
+            if (changed) rowCountVersion++;
+        });
     });
 
     // Rebuild the prefix-sum table when wrap is on and any geometry input
@@ -378,7 +406,8 @@
     $effect(() => {
         const fn = fetchLogs;
         const cs = chunkSize;
-        fetcher = new LogFetcher(cache, fn, cs, () => {
+        fetcher = new LogFetcher(cache, fn, cs, (min, max) => {
+            measureRange(min, max);
             if (isAutoScroll && !userScrolledUp) {
                 requestAnimationFrame(() => scrollToBottom());
             }
@@ -484,7 +513,8 @@
 
     export function onStream(event: LogEvent) {
         const prevTotal = cache.totalLines;
-        cache.applyEvent(event);
+        const merged = cache.applyEvent(event);
+        if (merged.touched) measureRange(merged.min, merged.max);
 
         if (cache.totalLines > prevTotal && isAutoScroll && !userScrolledUp) {
             requestAnimationFrame(() => scrollToBottom());

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

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { describe, expect, it } from "vitest";
-import { FAILURE_END_REASONS, END_REASONS } from "@runwisp/common";
+import { END_REASONS } from "@runwisp/common";
 import {
     emptyRunFilters,
+    FAILURE_STATUS_TOKEN,
     NEEDS_ATTENTION_STATUSES,
     isNeedsAttention,
     dimensionActive,
@@ -59,14 +60,11 @@ describe("isNeedsAttention", () => {
         expect(isNeedsAttention([...NEEDS_ATTENTION_STATUSES].reverse())).toBe(true);
     });
 
-    it("includes every failure reason plus missed", () => {
-        for (const reason of FAILURE_END_REASONS) {
-            expect(NEEDS_ATTENTION_STATUSES).toContain(reason);
-        }
-        expect(NEEDS_ATTENTION_STATUSES).toContain("missed");
+    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 strict subset or a different set", () => {
+    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);
@@ -172,32 +170,58 @@ describe("statusChipLabel", () => {
 });
 
 describe("STATUS_BUCKETS", () => {
-    it("covers every filterable status exactly once", () => {
+    // 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.
+    const FAILURE_REASONS = [
+        "failed",
+        "crashed",
+        "timeout",
+        "log_overflow",
+        "start_failed",
+        "missed",
+    ];
+
+    it("no status appears in two buckets", () => {
         const all = STATUS_BUCKETS.flatMap((b) => [...b.statuses]);
-        expect(new Set(all).size).toBe(all.length); // no status in two buckets
-        expect(new Set(all)).toEqual(new Set([...END_REASONS, "pending", "running"]));
+        expect(new Set(all).size).toBe(all.length);
     });
 
-    it("Failed bucket is the needs-attention set", () => {
-        expect(new Set(bucketByKey("failed").statuses)).toEqual(new Set(NEEDS_ATTENTION_STATUSES));
+    it("buckets cover every non-failure status plus the failure sentinel", () => {
+        const all = new Set(STATUS_BUCKETS.flatMap((b) => [...b.statuses]));
+        const nonFailureReasons = END_REASONS.filter((r) => !FAILURE_REASONS.includes(r));
+        expect(all).toEqual(
+            new Set([...nonFailureReasons, "pending", "running", FAILURE_STATUS_TOKEN]),
+        );
+    });
+
+    it("Failed bucket is the failure sentinel", () => {
+        expect(bucketByKey("failed").statuses).toEqual([FAILURE_STATUS_TOKEN]);
     });
 });
 
 describe("bucketState / toggleBucket", () => {
-    const failed = bucketByKey("failed");
+    const failed = bucketByKey("failed"); // single-token (the failure sentinel)
+    const running = bucketByKey("running"); // multi-member: pending + running
 
-    it("reads off / partial / on", () => {
+    it("reads off / on for the single-token Failed bucket", () => {
         expect(bucketState([], failed)).toBe("off");
-        expect(bucketState(["failed"], failed)).toBe("partial");
+        expect(bucketState(["failed"], failed)).toBe("off"); // a raw reason is not the sentinel
         expect(bucketState([...failed.statuses], failed)).toBe("on");
     });
 
+    it("reads off / partial / on for a multi-member bucket", () => {
+        expect(bucketState([], running)).toBe("off");
+        expect(bucketState(["running"], running)).toBe("partial");
+        expect(bucketState([...running.statuses], running)).toBe("on");
+    });
+
     it("selects all of an off or partial bucket", () => {
-        const fromOff = toggleBucket(base(), failed);
-        expect(new Set(fromOff.statuses)).toEqual(new Set(failed.statuses));
+        const fromOff = toggleBucket(base(), running);
+        expect(new Set(fromOff.statuses)).toEqual(new Set(running.statuses));
 
-        const fromPartial = toggleBucket(base({ statuses: ["failed"] }), failed);
-        expect(new Set(fromPartial.statuses)).toEqual(new Set(failed.statuses));
+        const fromPartial = toggleBucket(base({ statuses: ["running"] }), running);
+        expect(new Set(fromPartial.statuses)).toEqual(new Set(running.statuses));
     });
 
     it("clears a fully-selected bucket without touching other statuses", () => {
@@ -237,7 +261,9 @@ describe("date helpers", () => {
 describe("triggerDescription", () => {
     it("gives a fuller label than the row badge", () => {
         expect(triggerDescription("cron")).toBe("Scheduled (cron)");
-        expect(triggerDescription("api")).toBe("Manual (UI or API)");
+        expect(triggerDescription("api")).toBe("REST API");
+        expect(triggerDescription("ui")).toBe("UI");
+        expect(triggerDescription("cli")).toBe("CLI");
         expect(triggerDescription("service")).toBe("Service auto-start");
         expect(triggerDescription("startup")).toBe("On daemon start");
     });
@@ -249,7 +275,7 @@ describe("triggerDescription", () => {
 
 describe("FILTERABLE_TRIGGERS", () => {
     it("offers every trigger except cloud", () => {
-        expect(FILTERABLE_TRIGGERS).toEqual(["cron", "api", "service", "startup"]);
+        expect(FILTERABLE_TRIGGERS).toEqual(["cron", "api", "ui", "cli", "service", "startup"]);
         expect(FILTERABLE_TRIGGERS).not.toContain("cloud");
     });
 });

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

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: PoppyCake, s.r.o.
 // SPDX-License-Identifier: Apache-2.0
 
-import { FAILURE_END_REASONS, TRIGGERS, type Trigger } from "@runwisp/common";
+import { TRIGGERS, type Trigger } from "@runwisp/common";
 
 export type RunsListSortDirection = "asc" | "desc" | "";
 
@@ -42,12 +42,23 @@ export function emptyRunFilters(): RunsListFilters {
 }
 
 /**
- * Statuses worth an operator's attention: every end reason the retry policy
- * treats as a failure, plus `missed` (a scheduled run the daemon was down
- * for). Backs the one-click preset that serves Prime Directive #1 — nothing
- * silently fails.
+ * 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.
  */
-export const NEEDS_ATTENTION_STATUSES: readonly string[] = [...FAILURE_END_REASONS, "missed"];
+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 {
@@ -214,8 +225,10 @@ export function humanizeStatus(status: string): string {
 
 /**
  * Descriptive label for a run's trigger source — fuller than the one-word row
- * badge (`formatTriggeredByLabel`), for the filter dropdown and chip where the
- * extra words disambiguate (e.g. "Manual (UI or API)" vs a bare "API").
+ * badge (`formatTriggeredByLabel`) for the "cron"/"cloud"/"service"/"startup"
+ * sources, where the extra words disambiguate (e.g. "REST API" vs a bare
+ * "API"). "ui" and "cli" already read fine as their bare badge word, so those
+ * two 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).
@@ -225,7 +238,11 @@ export function triggerDescription(trigger: string): string {
         case "cron":
             return "Scheduled (cron)";
         case "api":
-            return "Manual (UI or API)";
+            return "REST API";
+        case "ui":
+            return "UI";
+        case "cli":
+            return "CLI";
         case "cloud":
             return "Control plane";
         case "service":

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

@@ -107,6 +107,8 @@ describe("runStartDelay", () => {
 describe("formatTriggeredByLabel", () => {
     it("humanizes each trigger source", () => {
         expect(formatTriggeredByLabel("api")).toBe("API");
+        expect(formatTriggeredByLabel("ui")).toBe("UI");
+        expect(formatTriggeredByLabel("cli")).toBe("CLI");
         expect(formatTriggeredByLabel("cron")).toBe("Cron");
         expect(formatTriggeredByLabel("service")).toBe("Service");
         expect(formatTriggeredByLabel("startup")).toBe("Startup");

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

@@ -85,6 +85,8 @@ export function instanceSuffix(instanceIndex: number, instanceCount: number): st
 /** 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";

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

@@ -151,7 +151,7 @@ export const RUN_STATUS_CONFIG: Record<RunStatus, RunStatusConfig> = {
         dot: "bg-danger-surface",
         badge: "bg-danger-soft text-danger-soft-text",
         description:
-            "The service kept failing to stay up for healthy_after; after restart_attempts the supervisor gave up (FATAL) and stopped restarting it.",
+            "The run (or service instance) kept failing; after restart_attempts consecutive failures, RunWisp gave up restarting it automatically.",
     },
     pending: {
         icon: Clock,

package/src/lib/index.ts

@@ -84,6 +84,7 @@ export { default as RunFilterPopover } from "./components/dashboard/RunFilterPop
 export type { RunOutputMatch } from "./components/dashboard/RunsList.svelte";
 export {
     emptyRunFilters,
+    FAILURE_STATUS_TOKEN,
     NEEDS_ATTENTION_STATUSES,
     isNeedsAttention,
     activeFilterCount,