@runwisp/ui 0.10.0 → 0.12.0

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.replaceAll("_", " ");
+    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(Number);
+    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()}`;
+}

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

@@ -7,6 +7,7 @@ import {
     runStartDelay,
     formatTriggeredByLabel,
     runRetryLabel,
+    instanceSuffix,
 } from "./run-helpers.js";
 
 describe("runDuration", () => {
@@ -39,6 +40,19 @@ describe("runDuration", () => {
             expect(runDuration({ start_at: "2024-06-15T12:00:00.000Z" })).toBe("2s");
         });
     });
+
+    it("counts against an injected now for an in-progress run", () => {
+        const start = "2024-06-15T12:00:00.000Z";
+        const now = new Date("2024-06-15T12:00:07.000Z").getTime();
+        expect(runDuration({ start_at: start }, now)).toBe("7s");
+    });
+
+    it("ignores the injected now once the run has ended", () => {
+        const start = "2024-06-15T12:00:00.000Z";
+        const end = "2024-06-15T12:00:05.000Z";
+        const now = new Date("2024-06-15T12:01:00.000Z").getTime();
+        expect(runDuration({ start_at: start, end_at: end }, now)).toBe("5s");
+    });
 });
 
 describe("runStartDelay", () => {
@@ -88,3 +102,22 @@ describe("runRetryLabel", () => {
         expect(runRetryLabel({ retry_attempt: 1, retry_of_run_id: "01JABC" })).toBe("retry #1");
     });
 });
+
+describe("instanceSuffix", () => {
+    it("returns no suffix for a single-instance task", () => {
+        expect(instanceSuffix(0, 1)).toBe("");
+    });
+
+    it("returns no suffix for a non-service (count 0)", () => {
+        expect(instanceSuffix(0, 0)).toBe("");
+    });
+
+    it("suffixes slot 0 of a multi-instance service as #1 (1-based)", () => {
+        expect(instanceSuffix(0, 3)).toBe("#1");
+    });
+
+    it("maps the stored 0-based slot to a 1-based suffix", () => {
+        expect(instanceSuffix(1, 3)).toBe("#2");
+        expect(instanceSuffix(2, 3)).toBe("#3");
+    });
+});

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

@@ -4,10 +4,13 @@
 import type { Run } from "@runwisp/common";
 import { formatDuration } from "../../utils/format.js";
 
-export function runDuration(run: Pick<Run, "start_at" | "end_at">): string | undefined {
+export function runDuration(
+    run: Pick<Run, "start_at" | "end_at">,
+    now: number = Date.now(),
+): string | undefined {
     if (!run.start_at) return undefined;
     const start = new Date(run.start_at).getTime();
-    const end = run.end_at ? new Date(run.end_at).getTime() : Date.now();
+    const end = run.end_at ? new Date(run.end_at).getTime() : now;
     return formatDuration(end - start);
 }
 
@@ -26,6 +29,21 @@ export function runStartDelay(run: Pick<Run, "created_at" | "start_at">): 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.
+ */
+export function instanceSuffix(instanceIndex: number, instanceCount: number): string {
+    if (instanceCount > 1) {
+        return `#${String(instanceIndex + 1)}`;
+    }
+    return "";
+}
+
 /** Human label for why a run fired (the `triggered_by` source). */
 export function formatTriggeredByLabel(triggeredBy: Run["triggered_by"]): string {
     if (triggeredBy === "api") return "API";

package/src/lib/index.ts

@@ -80,10 +80,25 @@ export { LogFetcher } from "./log-console/LogFetcher.svelte.js";
 
 export { default as RunDetailPanel } from "./components/dashboard/RunDetailPanel.svelte";
 export { default as RunsList } from "./components/dashboard/RunsList.svelte";
-export type {
-    RunsListFilters,
-    RunsListSortDirection,
-} from "./components/dashboard/RunsList.svelte";
+export { default as RunFilterPopover } from "./components/dashboard/RunFilterPopover.svelte";
+export type { RunOutputMatch } from "./components/dashboard/RunsList.svelte";
+export {
+    emptyRunFilters,
+    NEEDS_ATTENTION_STATUSES,
+    isNeedsAttention,
+    activeFilterCount,
+    activeDimensions,
+    dimensionActive,
+    clearDimension,
+    clearPopoverFilters,
+    humanizeStatus,
+    statusChipLabel,
+    exitCodeRange,
+    type ExitCodeRange,
+    type RunsListFilters,
+    type RunsListSortDirection,
+    type FilterDimension,
+} from "./components/dashboard/run-filters.js";
 export {
     getRunStatusConfig,
     runDisplayStatus,
@@ -96,6 +111,7 @@ export {
     runPhaseOrder,
     formatTriggeredByLabel,
     runRetryLabel,
+    instanceSuffix,
 } from "./components/dashboard/run-helpers.js";
 export { humanizeCron, type HumanizedCron } from "./components/dashboard/cron-format.js";
 export type { DaemonState, DaemonStats } from "./components/dashboard/types.js";
@@ -111,3 +127,4 @@ export {
     formatFullDateTime,
 } from "./utils/format.js";
 export { formatShortId } from "./utils/id.js";
+export { TickingNow } from "./utils/ticking-now.svelte.js";

package/src/lib/log-console/LogCache.svelte.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: PoppyCake, s.r.o.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { LogSlice, LogEvent } from "./types.js";
+import type { LogSlice, LogEvent, RegionUpdate } from "./types.js";
 import { SvelteMap } from "svelte/reactivity";
 import { visibleColumns } from "./ansi.js";
 
@@ -12,8 +12,21 @@ import { visibleColumns } from "./ansi.js";
  * the cache must aggressively prune data that is far from the current viewport.
  * It uses a SvelteMap for reactive, efficient line lookups and updates.
  */
+// Streams pinned to the front of the overlay, in render order. The companion
+// Set backs the membership test in `overlayRows`. Both are module-level,
+// immutable, and non-reactive — a fixed lookup table, not component state.
+const PREFERRED_STREAM_ORDER = ["stdout", "stderr"] as const;
+const PREFERRED_STREAMS: ReadonlySet<string> = new Set(PREFERRED_STREAM_ORDER);
+
 export class LogCache {
     lines = $state(new SvelteMap<number, string>());
+    // Live-region overlay, keyed by stream (stdout/stderr). Each stream has at
+    // most one active region; the frame is replaced wholesale on each update and
+    // never persisted. Rendered below the committed lines as an in-place tail.
+    regions = $state(new SvelteMap<string, { epoch: number; rows: string[] }>());
+    // Per-line frame-history counts. A non-zero entry marks a settled progress
+    // bar / multi-line redraw whose prior frames can be fetched on click.
+    frameCounts = $state(new SvelteMap<number, number>());
     totalLines = $state(0);
     totalBytes = $state(0);
     finished = $state(false);
@@ -50,13 +63,52 @@ export class LogCache {
         return { touched, min, max };
     }
 
+    // Flattened overlay rows for rendering, stdout before stderr (then any
+    // other streams, sorted) for stable ordering. Reactive: reads the regions
+    // map so it recomputes on update.
+    get overlayRows(): string[] {
+        const rest = [...this.regions.keys()]
+            .filter((s) => !PREFERRED_STREAMS.has(s))
+            .sort((a, b) => a.localeCompare(b));
+        const out: string[] = [];
+        for (const stream of [...PREFERRED_STREAM_ORDER, ...rest]) {
+            const region = this.regions.get(stream);
+            if (region) out.push(...region.rows);
+        }
+        return out;
+    }
+
+    applyRegion(update: RegionUpdate) {
+        if (update.rows.length === 0) {
+            this.regions.delete(update.stream);
+            return;
+        }
+        this.regions.set(update.stream, { epoch: update.epoch, rows: update.rows });
+        for (const row of update.rows) {
+            this.maxLineColumns = Math.max(this.maxLineColumns, visibleColumns(row));
+        }
+    }
+
     applyEvent(event: LogEvent) {
+        if (event.region) {
+            this.applyRegion(event.region);
+            return { touched: false, min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY };
+        }
         this.totalLines = Math.max(this.totalLines, Math.floor(event.sizeLines));
         this.totalBytes = Math.max(this.totalBytes, Math.floor(event.sizeBytes ?? 0));
         this.finished = event.finished;
+        // A finished run has no live region; drop any lingering overlay so a
+        // dropped clear-frame can't leave a stale tail painted forever.
+        if (event.finished && this.regions.size > 0) this.regions.clear();
         if (event.firstAvailableLine !== undefined && event.firstAvailableLine > 0) {
             this.firstAvailableLine = Math.max(this.firstAvailableLine, event.firstAvailableLine);
         }
+        if (event.frameCounts) {
+            for (const [k, v] of Object.entries(event.frameCounts)) {
+                const line = Number(k);
+                if (Number.isFinite(line) && line >= 0 && v > 0) this.frameCounts.set(line, v);
+            }
+        }
 
         return this.mergeSlice(event.lines);
     }
@@ -78,6 +130,8 @@ export class LogCache {
 
     reset() {
         this.lines.clear();
+        this.regions.clear();
+        this.frameCounts.clear();
         this.totalLines = 0;
         this.totalBytes = 0;
         this.finished = false;

package/src/lib/log-console/types.ts

@@ -3,12 +3,29 @@
 
 export type LogSlice = Record<number, string>;
 
+/**
+ * RegionUpdate is a live snapshot of a still-animating output region (a `\r`
+ * progress bar or a multi-line ANSI redraw). It is never persisted: the cache
+ * holds it in a transient overlay keyed by stream, replacing the whole frame on
+ * each update. Empty `rows` clears the overlay for that stream.
+ */
+export type RegionUpdate = {
+    stream: string;
+    epoch: number;
+    rows: string[];
+};
+
 export type LogEvent = {
     lines: LogSlice;
     sizeLines: number;
     sizeBytes?: number;
     finished: boolean;
     firstAvailableLine?: number;
+    region?: RegionUpdate;
+    // Per-line count of recorded prior frames, keyed by line number. Present only
+    // for settled progress-bar / multi-line-redraw anchor lines, marking them as
+    // clickable to rewind through earlier states. Plain lines are absent.
+    frameCounts?: Record<number, number>;
 };
 
 export function isLogEvent(value: unknown): value is LogEvent {