@runwisp/ui 0.10.0 → 0.11.0

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

@@ -0,0 +1,299 @@
+// SPDX-FileCopyrightText: PoppyCake, s.r.o.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from "vitest";
+import { FAILURE_END_REASONS, END_REASONS } from "@runwisp/common";
+import {
+    emptyRunFilters,
+    NEEDS_ATTENTION_STATUSES,
+    isNeedsAttention,
+    dimensionActive,
+    activeDimensions,
+    activeFilterCount,
+    clearDimension,
+    clearPopoverFilters,
+    humanizeStatus,
+    triggerDescription,
+    FILTERABLE_TRIGGERS,
+    statusChipLabel,
+    STATUS_BUCKETS,
+    bucketState,
+    toggleBucket,
+    dayStartIso,
+    dayEndIso,
+    isoToDayInput,
+    isWholeDay,
+    parseExitCodeRange,
+    exitCodeRange,
+    exitCodeRangeActive,
+    isExitCodeExprValid,
+    exitCodeChipLabel,
+    type StatusBucket,
+    type RunsListFilters,
+} from "./run-filters.js";
+
+function bucketByKey(key: string): StatusBucket {
+    const bucket = STATUS_BUCKETS.find((b) => b.key === key);
+    if (!bucket) throw new Error(`no bucket ${key}`);
+    return bucket;
+}
+
+const base = (overrides: Partial<RunsListFilters> = {}): RunsListFilters => ({
+    ...emptyRunFilters(),
+    ...overrides,
+});
+
+describe("emptyRunFilters", () => {
+    it("is a fully-open filter — no dimension active, newest-first", () => {
+        const f = emptyRunFilters();
+        expect(f.statuses).toEqual([]);
+        expect(f.sort_direction).toBe("desc");
+        expect(activeFilterCount(f)).toBe(0);
+    });
+});
+
+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("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 false for a strict subset or a different set", () => {
+        expect(isNeedsAttention(["failed"])).toBe(false);
+        expect(isNeedsAttention(["success"])).toBe(false);
+        expect(isNeedsAttention([])).toBe(false);
+    });
+});
+
+describe("dimensionActive / activeDimensions", () => {
+    it("detects each dimension independently", () => {
+        expect(dimensionActive(base({ statuses: ["failed"] }), "status")).toBe(true);
+        expect(dimensionActive(base({ created_after: "2026-01-01T00:00:00Z" }), "time")).toBe(true);
+        expect(dimensionActive(base({ created_before: "2026-01-01T00:00:00Z" }), "time")).toBe(
+            true,
+        );
+        expect(dimensionActive(base({ task_name: "backup" }), "task")).toBe(true);
+        expect(dimensionActive(base({ triggered_by: "cron" }), "triggered_by")).toBe(true);
+        expect(dimensionActive(base({ exit_code: "137" }), "exit_code")).toBe(true);
+        expect(dimensionActive(base({ exit_code: ">100" }), "exit_code")).toBe(true);
+        expect(dimensionActive(base({ retries_only: true }), "retries")).toBe(true);
+    });
+
+    it("treats an exact exit code of 0 as active (distinct from absent)", () => {
+        expect(dimensionActive(base({ exit_code: "0" }), "exit_code")).toBe(true);
+    });
+
+    it("treats an empty or unparseable exit-code expression as inactive", () => {
+        expect(dimensionActive(base({ exit_code: "" }), "exit_code")).toBe(false);
+        expect(dimensionActive(base({ exit_code: "nonsense" }), "exit_code")).toBe(false);
+    });
+
+    it("lists active dimensions in display (most→least useful) order", () => {
+        const f = base({
+            retries_only: true,
+            statuses: ["failed"],
+            triggered_by: "cron",
+            created_after: "2026-01-01T00:00:00Z",
+        });
+        expect(activeDimensions(f)).toEqual(["status", "time", "triggered_by", "retries"]);
+    });
+});
+
+describe("clearDimension", () => {
+    it("resets one dimension and leaves the rest untouched", () => {
+        const f = base({ statuses: ["failed"], triggered_by: "cron", retries_only: true });
+        const cleared = clearDimension(f, "triggered_by");
+        expect(cleared.triggered_by).toBeUndefined();
+        expect(cleared.statuses).toEqual(["failed"]);
+        expect(cleared.retries_only).toBe(true);
+    });
+
+    it("clears the exit-code expression", () => {
+        const f = base({ exit_code: ">100 <150" });
+        expect(clearDimension(f, "exit_code").exit_code).toBeUndefined();
+    });
+
+    it("clears both time bounds together", () => {
+        const f = base({ created_after: "2026-01-01T00:00:00Z", created_before: "2026-02-01" });
+        const cleared = clearDimension(f, "time");
+        expect(cleared.created_after).toBeUndefined();
+        expect(cleared.created_before).toBeUndefined();
+    });
+});
+
+describe("clearPopoverFilters", () => {
+    it("clears every popover dimension but keeps search and sort", () => {
+        const f = base({
+            search: "nightly",
+            sort_direction: "asc",
+            statuses: ["failed"],
+            task_name: "backup",
+            triggered_by: "cron",
+            exit_code: "1",
+            retries_only: true,
+            created_after: "2026-01-01T00:00:00Z",
+        });
+        const cleared = clearPopoverFilters(f);
+        expect(activeFilterCount(cleared)).toBe(0);
+        expect(cleared.search).toBe("nightly");
+        expect(cleared.sort_direction).toBe("asc");
+    });
+});
+
+describe("humanizeStatus", () => {
+    it("title-cases and de-snakes a status token", () => {
+        expect(humanizeStatus("log_overflow")).toBe("Log overflow");
+        expect(humanizeStatus("failed")).toBe("Failed");
+        expect(humanizeStatus("")).toBe("");
+    });
+});
+
+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");
+        expect(statusChipLabel(["pending", "running"])).toBe("Running");
+        expect(statusChipLabel(["success"])).toBe("Succeeded");
+    });
+
+    it("humanizes a single status that is not a whole bucket", () => {
+        expect(statusChipLabel(["log_overflow"])).toBe("Log overflow");
+    });
+
+    it("counts a multi-status set that matches no bucket", () => {
+        expect(statusChipLabel(["failed", "crashed"])).toBe("2 statuses");
+    });
+});
+
+describe("STATUS_BUCKETS", () => {
+    it("covers every filterable status exactly once", () => {
+        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"]));
+    });
+
+    it("Failed bucket is the needs-attention set", () => {
+        expect(new Set(bucketByKey("failed").statuses)).toEqual(new Set(NEEDS_ATTENTION_STATUSES));
+    });
+});
+
+describe("bucketState / toggleBucket", () => {
+    const failed = bucketByKey("failed");
+
+    it("reads off / partial / on", () => {
+        expect(bucketState([], failed)).toBe("off");
+        expect(bucketState(["failed"], failed)).toBe("partial");
+        expect(bucketState([...failed.statuses], failed)).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 fromPartial = toggleBucket(base({ statuses: ["failed"] }), failed);
+        expect(new Set(fromPartial.statuses)).toEqual(new Set(failed.statuses));
+    });
+
+    it("clears a fully-selected bucket without touching other statuses", () => {
+        const f = base({ statuses: [...failed.statuses, "success"] });
+        const cleared = toggleBucket(f, failed);
+        expect(cleared.statuses).toEqual(["success"]);
+    });
+});
+
+describe("date helpers", () => {
+    it("round-trips a day through its start/end bounds in local time", () => {
+        const start = dayStartIso("2016-07-10");
+        const end = dayEndIso("2016-07-10");
+        expect(isoToDayInput(start ?? "")).toBe("2016-07-10");
+        expect(isoToDayInput(end ?? "")).toBe("2016-07-10");
+        expect(new Date(start ?? "").getTime()).toBeLessThan(new Date(end ?? "").getTime());
+    });
+
+    it("ignores a malformed date", () => {
+        expect(dayStartIso("not-a-date")).toBeUndefined();
+        expect(dayEndIso("2016-13")).toBeUndefined();
+    });
+
+    it("isWholeDay is true when From and To bound the same day", () => {
+        // Picking the same date for both ends (start-of-day .. end-of-day) is a
+        // whole-day range, so the chip can read "On <date>".
+        expect(isWholeDay(dayStartIso("2016-07-10"), dayEndIso("2016-07-10"))).toBe(true);
+    });
+
+    it("isWholeDay is false for partial or multi-day ranges", () => {
+        expect(isWholeDay(undefined, undefined)).toBe(false);
+        expect(isWholeDay(dayStartIso("2016-07-10"), undefined)).toBe(false);
+        expect(isWholeDay(dayStartIso("2016-07-10"), dayEndIso("2016-07-12"))).toBe(false);
+    });
+});
+
+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("service")).toBe("Service auto-start");
+        expect(triggerDescription("startup")).toBe("On daemon start");
+    });
+
+    it("falls back to a humanized token for anything unknown", () => {
+        expect(triggerDescription("whatever_else")).toBe("Whatever else");
+    });
+});
+
+describe("FILTERABLE_TRIGGERS", () => {
+    it("offers every trigger except cloud", () => {
+        expect(FILTERABLE_TRIGGERS).toEqual(["cron", "api", "service", "startup"]);
+        expect(FILTERABLE_TRIGGERS).not.toContain("cloud");
+    });
+});
+
+describe("exit-code expression", () => {
+    it("parses an exact code as an inclusive [n, n] range", () => {
+        expect(parseExitCodeRange("137")).toEqual({ range: { min: 137, max: 137 }, valid: true });
+        expect(parseExitCodeRange("-2")).toEqual({ range: { min: -2, max: -2 }, valid: true });
+    });
+
+    it("normalizes strict comparisons to inclusive integer bounds", () => {
+        expect(exitCodeRange(">100")).toEqual({ min: 101 });
+        expect(exitCodeRange(">=100")).toEqual({ min: 100 });
+        expect(exitCodeRange("<150")).toEqual({ max: 149 });
+        expect(exitCodeRange("<=150")).toEqual({ max: 150 });
+    });
+
+    it("combines space-separated tokens into a window", () => {
+        expect(exitCodeRange(">100 <150")).toEqual({ min: 101, max: 149 });
+        expect(exitCodeRange(">=1 <=255")).toEqual({ min: 1, max: 255 });
+    });
+
+    it("treats an empty expression as valid with no bounds", () => {
+        expect(parseExitCodeRange("")).toEqual({ range: {}, valid: true });
+        expect(parseExitCodeRange("   ")).toEqual({ range: {}, valid: true });
+        expect(exitCodeRangeActive("")).toBe(false);
+    });
+
+    it("rejects an unparseable token, applying none of it", () => {
+        expect(isExitCodeExprValid("12a")).toBe(false);
+        expect(isExitCodeExprValid(">>5")).toBe(false);
+        expect(exitCodeRange("12a")).toEqual({});
+        expect(exitCodeRangeActive("12a")).toBe(false);
+    });
+
+    it("reports activity only when a bound resolves", () => {
+        expect(exitCodeRangeActive("137")).toBe(true);
+        expect(exitCodeRangeActive(">0")).toBe(true);
+        expect(exitCodeRangeActive(undefined)).toBe(false);
+    });
+
+    it("labels the chip with the raw expression", () => {
+        expect(exitCodeChipLabel(">100 <150")).toBe("Exit >100 <150");
+        expect(exitCodeChipLabel(" 137 ")).toBe("Exit 137");
+    });
+});

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

@@ -0,0 +1,384 @@
+// SPDX-FileCopyrightText: PoppyCake, s.r.o.
+// SPDX-License-Identifier: Apache-2.0
+
+import { FAILURE_END_REASONS, TRIGGERS, type Trigger } from "@runwisp/common";
+
+export type RunsListSortDirection = "asc" | "desc" | "";
+
+/**
+ * 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
+ * `sort_direction` 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.
+ */
+export interface RunsListFilters {
+    search: string;
+    statuses: string[];
+    sort_direction: RunsListSortDirection;
+    // 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
+    // the parent's fetch effect through several levels of `bind:`.
+    task_name?: string | undefined;
+    created_after?: string | undefined;
+    created_before?: string | undefined;
+    triggered_by?: 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 `exit_code_min` / `exit_code_max`.
+    exit_code?: string | undefined;
+    retries_only?: boolean | undefined;
+}
+
+/** A fresh default filter — no dimensions active, newest-first. */
+export function emptyRunFilters(): RunsListFilters {
+    return { search: "", statuses: [], sort_direction: "desc" };
+}
+
+/**
+ * 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.
+ */
+export const NEEDS_ATTENTION_STATUSES: readonly string[] = [...FAILURE_END_REASONS, "missed"];
+
+/** 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.
+ */
+export interface StatusBucket {
+    key: string;
+    label: string;
+    /** Tailwind background class for the bucket's status dot. */
+    dot: string;
+    statuses: readonly string[];
+}
+
+export const STATUS_BUCKETS: readonly StatusBucket[] = [
+    { key: "running", label: "Running", dot: "bg-info-surface", statuses: ["pending", "running"] },
+    { key: "succeeded", label: "Succeeded", dot: "bg-success-surface", statuses: ["success"] },
+    {
+        key: "failed",
+        label: "Failed",
+        dot: "bg-danger-surface",
+        statuses: NEEDS_ATTENTION_STATUSES,
+    },
+    {
+        key: "skipped",
+        label: "Skipped",
+        dot: "bg-on-surface-faint",
+        statuses: ["skipped", "dst_skipped", "queue_full"],
+    },
+    {
+        key: "stopped",
+        label: "Stopped",
+        dot: "bg-warning-surface",
+        statuses: ["stopped", "daemon_stopped"],
+    },
+];
+
+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;
+    if (present === 0) return "off";
+    if (present === bucket.statuses.length) return "on";
+    return "partial";
+}
+
+/** Toggle a whole bucket: fully selected → clear it; otherwise select all of it. */
+export function toggleBucket(f: RunsListFilters, bucket: StatusBucket): RunsListFilters {
+    const members = new Set(bucket.statuses);
+    if (bucketState(f.statuses, bucket) === "on") {
+        return { ...f, statuses: f.statuses.filter((s) => !members.has(s)) };
+    }
+    return { ...f, statuses: [...new Set([...f.statuses, ...bucket.statuses])] };
+}
+
+/** The bucket the selection matches exactly (all of it, nothing else), if any. */
+function exactBucket(statuses: string[]): StatusBucket | undefined {
+    return STATUS_BUCKETS.find(
+        (b) => b.statuses.length === statuses.length && bucketState(statuses, b) === "on",
+    );
+}
+
+/**
+ * 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
+ * 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.
+ */
+export type FilterDimension = "status" | "time" | "task" | "triggered_by" | "exit_code" | "retries";
+
+const DIMENSION_ORDER: FilterDimension[] = [
+    "status",
+    "time",
+    "task",
+    "triggered_by",
+    "exit_code",
+    "retries",
+];
+
+/** Whether a single dimension is currently constraining the result set. */
+export function dimensionActive(f: RunsListFilters, dim: FilterDimension): boolean {
+    switch (dim) {
+        case "status":
+            return f.statuses.length > 0;
+        case "time":
+            return Boolean(f.created_after) || Boolean(f.created_before);
+        case "task":
+            return Boolean(f.task_name);
+        case "triggered_by":
+            return Boolean(f.triggered_by);
+        case "exit_code":
+            return exitCodeRangeActive(f.exit_code);
+        case "retries":
+            return Boolean(f.retries_only);
+    }
+}
+
+/** 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. */
+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":
+            return { ...f, statuses: [] };
+        case "time":
+            return { ...f, created_after: undefined, created_before: undefined };
+        case "task":
+            return { ...f, task_name: undefined };
+        case "triggered_by":
+            return { ...f, triggered_by: undefined };
+        case "exit_code":
+            return { ...f, exit_code: undefined };
+        case "retries":
+            return { ...f, retries_only: undefined };
+    }
+}
+
+/**
+ * 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: [],
+        created_after: undefined,
+        created_before: undefined,
+        task_name: undefined,
+        triggered_by: undefined,
+        exit_code: undefined,
+        retries_only: undefined,
+    };
+}
+
+/** Human label for a status value, e.g. `log_overflow` → "Log overflow". */
+export function humanizeStatus(status: string): string {
+    if (!status) return status;
+    const spaced = status.replace(/_/g, " ");
+    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 filter dropdown and chip where the
+ * extra words disambiguate (e.g. "Manual (UI or API)" vs a bare "API").
+ *
+ * Note `cron` covers both on-time schedule firings and catch-up for missed
+ * runs, and `startup` is specifically `run_on_start` (not catch-up).
+ */
+export function triggerDescription(trigger: string): string {
+    switch (trigger) {
+        case "cron":
+            return "Scheduled (cron)";
+        case "api":
+            return "Manual (UI or API)";
+        case "cloud":
+            return "Control plane";
+        case "service":
+            return "Service auto-start";
+        case "startup":
+            return "On daemon start";
+        default:
+            return humanizeStatus(trigger);
+    }
+}
+
+/**
+ * The triggers offered in the filter dropdown. `cloud` is intentionally
+ * excluded for now — control-plane runs still carry the `cloud` trigger, but
+ * it isn't a selectable filter dimension.
+ */
+export const FILTERABLE_TRIGGERS: readonly Trigger[] = TRIGGERS.filter((t) => t !== "cloud");
+
+/** 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;
+    const [only] = statuses;
+    if (statuses.length === 1 && only !== undefined) return humanizeStatus(only);
+    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("-");
+    if (parts.length !== 3) return null;
+    const [y, m, d] = parts.map((p) => Number(p));
+    if (y === undefined || m === undefined || d === undefined) return null;
+    if (!Number.isInteger(y) || !Number.isInteger(m) || !Number.isInteger(d)) return null;
+    const date = new Date(y, m - 1, d);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+
+/** `YYYY-MM-DD` → that day's 00:00 local, as an RFC3339 instant. */
+export function dayStartIso(dateStr: string): string | undefined {
+    const d = localDay(dateStr);
+    return d ? d.toISOString() : undefined;
+}
+
+/** `YYYY-MM-DD` → that day's last millisecond local, as an RFC3339 instant. */
+export function dayEndIso(dateStr: string): string | undefined {
+    const d = localDay(dateStr);
+    if (!d) return undefined;
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 23, 59, 59, 999).toISOString();
+}
+
+/** An RFC3339 instant → the local `YYYY-MM-DD` it falls on (for date inputs). */
+export function isoToDayInput(iso: string): string {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime())) return "";
+    const pad = (n: number) => String(n).padStart(2, "0");
+    return `${String(d.getFullYear())}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+/**
+ * True when the bounds describe exactly one calendar day (its 00:00 → end of
+ * day). Picking the same date for both From and To produces such a range, so
+ * the chip can read "On <date>" instead of a from–to pair.
+ */
+export function isWholeDay(after?: string, before?: string): boolean {
+    if (!after || !before) return false;
+    const a = isoToDayInput(after);
+    return (
+        a !== "" &&
+        a === isoToDayInput(before) &&
+        new Date(after).getTime() < new Date(before).getTime()
+    );
+}
+
+// --- 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;
+}
+
+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).
+ */
+export function parseExitCodeRange(expr: string): { range: ExitCodeRange; valid: boolean } {
+    const range: ExitCodeRange = {};
+    const tokens = expr.trim().split(/\s+/).filter(Boolean);
+    for (const tok of tokens) {
+        const m = EXIT_CODE_TOKEN.exec(tok);
+        if (!m) return { range: {}, valid: false };
+        const numStr = m[2];
+        if (numStr === undefined) return { range: {}, valid: false };
+        const n = Number.parseInt(numStr, 10);
+        switch (m[1]) {
+            case ">":
+                range.min = n + 1;
+                break;
+            case ">=":
+                range.min = n;
+                break;
+            case "<":
+                range.max = n - 1;
+                break;
+            case "<=":
+                range.max = n;
+                break;
+            default:
+                range.min = n;
+                range.max = n;
+        }
+    }
+    return { range, valid: true };
+}
+
+/** The resolved range for an expression, or an empty (unbounded) range if invalid. */
+export function exitCodeRange(expr: string | undefined): ExitCodeRange {
+    if (!expr) return {};
+    const { range, valid } = parseExitCodeRange(expr);
+    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. */
+export function isExitCodeExprValid(expr: string): boolean {
+    return parseExitCodeRange(expr).valid;
+}
+
+/** Chip label for an active exit-code filter, e.g. `Exit >100 <150`. */
+export function exitCodeChipLabel(expr: string | undefined): string {
+    return `Exit ${(expr ?? "").trim()}`;
+}