@gaia-ai/addon-gaia-ui 0.9.2 → 0.11.0

package/dist/src/Entity/project/Screen/projects-screen.js

@@ -1,6 +1,6 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
 import { ListCursor } from '../../../lib/cursor.js';
 import { AsyncScreen } from '../../../Screen/async-screen.js';
-import { presentation } from '../../../Screen/screen.js';
 import { listRowIds, listTableTree } from '../../collection.js';
 import { loadProjectRows, PROJECT_TABLE, } from '../Data/projects.js';
 /**
@@ -69,19 +69,22 @@ export class ProjectsScreen extends AsyncScreen {
             selectedIndex: this.selectedIndex,
         });
     }
-    present(context) {
+    chrome(context) {
         const rows = this.rows;
-        return presentation(this.surface(context), {
+        return {
             selectable: rows.length,
             selectedIndex: this.selectedIndex,
-            // The node a click on each row lands on (GAIA-340 Task 11), read off the
-            // SAME configuration that keys the rows — so the click target and the row
-            // node cannot be spelled two ways (GAIA-345 D2).
+            // Click targets match listTableTree row ids (GAIA-345 D2).
             rowIds: listRowIds(PROJECT_TABLE, rows),
             title: 'GAIA projects',
             meta: `${rows.length} registered project(s)  ·  ${context.services?.baseUrl ?? ''}`,
-            status: ' ↑↓ select · Enter open · n new · Tab tabs · q quit ',
-        });
+        };
+    }
+    actions() {
+        return [
+            actionItem('projects-new', 'n', 'new'),
+            actionItem('projects-tab', 'Tab', 'tabs'),
+        ];
     }
     activate(index, context) {
         const row = this.readyValue?.[index];

package/dist/src/Entity/run/Component/run-detail/index.js

@@ -8,12 +8,20 @@
 //
 // GAIA-340 D1 — the FIRST block to hand its content over as renderables rather
 // than as rows of text: the sections are built once, keyed, and turned into a
-// VNode tree. It shares the minimal-markdown rule with the blocks that still
-// compose rows (`markdownRow`), so a body line renders the same either way.
+// VNode tree.
+//
+// GAIA-372 D9 — IT IS `markdownRow`'S ONLY CALLER NOW, and the ATX-only rule is
+// THIS SCREEN'S rule rather than a rule shared with the ticket detail. A run log
+// entry is MACHINE OUTPUT, not authored Markdown: an agent line full of `*`, `_`
+// and backticks would be re-styled and have characters deleted by a renderer
+// meant for prose. So the log keeps the narrow rule while the ticket detail's
+// `gaia_rich` bodies go through `Component/markdown/`. Nothing about this screen's
+// behaviour changed; routing the log through the full subset is a separate
+// ticket, not a silent side effect of that one.
 //
 // Read-only by design (the ticket's own out-of-scope list): no write, no edit, no
 // navigation out of it except Esc.
-import { markdownRow } from '../../../../Component/section-list/index.js';
+import { markdownRow } from '../../../../Component/markdown/index.js';
 import { asString } from '../../../../lib/format.js';
 import { columnNode, textNode } from '../../../../lib/vnode.js';
 /** The sideloaded `gaia_run` with this id, or undefined. */
@@ -208,10 +216,10 @@ function flatRows(document, runId) {
         { key: `section-${section.key}`, text: section.heading, bold: true },
         ...section.rows.map((entry) => ({
             key: entry.key,
-            // The same minimal-markdown rule the row surface applies, from the same
-            // function — an ATX heading inside a body renders bold with its markers
-            // stripped, and a log line starting with `#` must not render one way on
-            // screen and another way in a pipe.
+            // The log's OWN minimal-markdown rule (GAIA-372 D9): an ATX heading inside
+            // a log entry renders bold with its markers stripped, and a log line
+            // starting with `#` must not render one way on screen and another way in a
+            // pipe. Nothing else in an entry is parsed, deliberately — see the header.
             ...markdownRow(entry.text),
         })),
         // The blank row between two sections, which the flattened surface pushed

package/dist/src/Entity/run/Data/query.d.ts

@@ -20,3 +20,13 @@ export declare function buildRunQueryParams(projectId: string, criteria: RunCrit
     size: number;
     index: number;
 }): DrupalJsonApiParams;
+/**
+ * Build the JSON:API query for one assignee's runs (GAIA-377 D2).
+ *
+ * Runs carry no user of their own — attribution is
+ * `ticket_id.assignee_user_id.id`, matching StatisticsCounter::SOURCES.
+ */
+export declare function buildUserRunQueryParams(userId: string, criteria: RunCriteria, page?: {
+    size: number;
+    index: number;
+}): DrupalJsonApiParams;

package/dist/src/Entity/run/Data/query.js

@@ -25,6 +25,22 @@ export function describeCriteria(criteria) {
 export function buildRunQueryParams(projectId, criteria, page = { size: LIST_PAGE_SIZE, index: 0 }) {
     const params = new DrupalJsonApiParams();
     params.addFilter('ticket_id.project_id.id', projectId);
+    applyRunCriteria(params, criteria, page);
+    return params;
+}
+/**
+ * Build the JSON:API query for one assignee's runs (GAIA-377 D2).
+ *
+ * Runs carry no user of their own — attribution is
+ * `ticket_id.assignee_user_id.id`, matching StatisticsCounter::SOURCES.
+ */
+export function buildUserRunQueryParams(userId, criteria, page = { size: LIST_PAGE_SIZE, index: 0 }) {
+    const params = new DrupalJsonApiParams();
+    params.addFilter('ticket_id.assignee_user_id.id', userId);
+    applyRunCriteria(params, criteria, page);
+    return params;
+}
+function applyRunCriteria(params, criteria, page) {
     if (criteria.closed !== null)
         params.addFilter('closed', criteria.closed ? '1' : '0');
     params.addInclude(['ticket_id']);
@@ -37,5 +53,4 @@ export function buildRunQueryParams(projectId, criteria, page = { size: LIST_PAG
     // Page one carries no offset, so its query is the shortest it can be.
     if (page.index > 0)
         params.addPageOffset(page.index * page.size);
-    return params;
 }

package/dist/src/Entity/run/Data/runs.d.ts

@@ -219,6 +219,8 @@ export type RunPage = Page<RunRow>;
  * `links.next`.
  */
 export declare function loadProjectRuns(client: DropshClient, projectId: string, criteria: RunCriteria, page?: number): Promise<RunPage>;
+/** One page of runs attributed to a user via ticket assignee (GAIA-377 D2). */
+export declare function loadUserRuns(client: DropshClient, userId: string, criteria: RunCriteria, page?: number): Promise<RunPage>;
 /**
  * Newest-STARTED first, and TOTAL (GAIA-255 D5).
  *

package/dist/src/Entity/run/Data/runs.js

@@ -7,7 +7,7 @@
 // no-request read of the ticket document (spec D7).
 import { loadPage, } from '../../collection.js';
 import { LIST_PAGE_SIZE } from '../../cycle.js';
-import { buildRunQueryParams } from './query.js';
+import { buildRunQueryParams, buildUserRunQueryParams, } from './query.js';
 import { deriveRunStatus, runStartedAge } from './status.js';
 /** Read a value as a string, or `undefined` when it is not one. */
 function str(value) {
@@ -217,6 +217,24 @@ export async function loadProjectRuns(client, projectId, criteria, page = 0) {
         return data.map((item) => mapRunData(item, ticketsById));
     }, page, window);
 }
+/** One page of runs attributed to a user via ticket assignee (GAIA-377 D2). */
+export async function loadUserRuns(client, userId, criteria, page = 0) {
+    const window = {
+        offset: page * LIST_PAGE_SIZE,
+        limit: LIST_PAGE_SIZE,
+    };
+    const params = buildUserRunQueryParams(userId, criteria, {
+        size: window.limit,
+        index: page,
+    });
+    return loadPage(client, 'gaia_run/gaia_run', params, (data, included) => {
+        const ticketsById = new Map();
+        for (const inc of included)
+            if (inc.id)
+                ticketsById.set(inc.id, inc);
+        return data.map((item) => mapRunData(item, ticketsById));
+    }, page, window);
+}
 /**
  * Newest-STARTED first, and TOTAL (GAIA-255 D5).
  *

package/dist/src/Entity/run/Screen/run-detail.d.ts

@@ -1,10 +1,17 @@
-import { BaseScreen, type ScreenContext } from '../../../Screen/screen.js';
+import type { VNode } from '@opentui/core';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
 import type { TicketDetailDocument } from '../../../types.js';
 export interface RunDetailInput {
     readonly document: TicketDetailDocument;
 }
 export declare const runDetailInputContext: import("../../../Routing/context.js").ContextKey<RunDetailInput>;
-export declare class RunDetailScreen extends BaseScreen {
+/**
+ * Run detail — normal {@link AsyncScreen}. The document arrives via navigation
+ * context (or empty); refresh is the shared R / ui-refresh path.
+ */
+export declare class RunDetailScreen extends AsyncScreen<TicketDetailDocument> {
     readonly frameId = "run";
     topTab(): null;
     static readonly route: {
@@ -17,20 +24,13 @@ export declare class RunDetailScreen extends BaseScreen {
         context: (_params: Readonly<Record<string, string>>, state: unknown, base: import("../../../Routing/context.js").ContextBag) => import("../../../Routing/context.js").ContextBag;
     };
     readonly id: string;
-    private document;
-    enter(context: ScreenContext): void;
-    /**
-     * GAIA-340 D1 — the first screen on the renderable side of the boundary.
-     *
-     * It hands over NODES: the component returns the block as a tree and this
-     * returns it with the three chrome labels beside it. There is no
-     * `render(context): string[]` any more, because there is no second
-     * description of the screen to keep in step with this one — the bold section
-     * headings that were `boldRows` indices into a row surface are props on the
-     * rows' own nodes now (D3), and the surface those indices pointed into is
-     * gone.
-     */
-    present(context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    reload(context: ScreenContext): void;
+    protected load(context: ScreenContext): Promise<TicketDetailDocument>;
+    protected renderLoading(): string[];
+    protected renderReady(document: TicketDetailDocument, context: ScreenContext): VNode;
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    /** Read-only — kernel basics cover ↑↓ / Esc / q; no extra chips. */
+    protected actions(): never[];
     /**
      * F5 — the pipe's own output, and it is `string[]`.
      *
@@ -41,13 +41,6 @@ export declare class RunDetailScreen extends BaseScreen {
      * path lays the body out on a cell grid of a fixed width, and a pipe has no
      * width — on run #4928 it clipped 420 transcript rows at 80 columns, losing
      * 97.7 % of a 1.34 MB captured agent transcript.
-     *
-     * This is NOT a `ScreenPresentation.lines` coming back (R3): `present()` still
-     * hands over a tree and nothing else. Both shapes are projections of the block's
-     * ONE keyed traversal (`flatRows`), so there is no second description of the
-     * screen to keep in step — see `tests/Screen/run-detail-non-tty.test.ts`, which
-     * asserts the two row for row.
      */
     renderNonInteractive(context: ScreenContext): string[];
-    reset(): void;
 }

package/dist/src/Entity/run/Screen/run-detail.js

@@ -1,8 +1,12 @@
 import { defineContext } from '../../../Routing/context.js';
-import { BaseScreen, presentation, } from '../../../Screen/screen.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
 import { runDetailRows, runDetailTitle, runDetailTree, } from '../Component/run-detail/index.js';
 export const runDetailInputContext = defineContext('run-detail-input', 'input');
-export class RunDetailScreen extends BaseScreen {
+/**
+ * Run detail — normal {@link AsyncScreen}. The document arrives via navigation
+ * context (or empty); refresh is the shared R / ui-refresh path.
+ */
+export class RunDetailScreen extends AsyncScreen {
     frameId = 'run';
     topTab() {
         return null;
@@ -19,30 +23,28 @@ export class RunDetailScreen extends BaseScreen {
             : base,
     };
     id = RunDetailScreen.route.id;
-    document = {};
-    enter(context) {
+    reload(context) {
+        this.retry(context);
+    }
+    load(context) {
         if (context.contexts?.has(runDetailInputContext))
-            this.document = context.contexts.get(runDetailInputContext).document;
-        context.requestDraw();
+            return Promise.resolve(context.contexts.get(runDetailInputContext).document);
+        return Promise.resolve({});
     }
-    /**
-     * GAIA-340 D1 — the first screen on the renderable side of the boundary.
-     *
-     * It hands over NODES: the component returns the block as a tree and this
-     * returns it with the three chrome labels beside it. There is no
-     * `render(context): string[]` any more, because there is no second
-     * description of the screen to keep in step with this one — the bold section
-     * headings that were `boldRows` indices into a row surface are props on the
-     * rows' own nodes now (D3), and the surface those indices pointed into is
-     * gone.
-     */
-    present(context) {
-        const runId = context.params?.runId ?? '';
-        return presentation(runDetailTree(this.document, runId), {
-            title: runDetailTitle(this.document, runId),
-            meta: '↑↓ scroll · Esc back · q quit',
-            status: ' ↑↓ scroll · Esc back · q quit ',
-        });
+    renderLoading() {
+        return ['Loading run…'];
+    }
+    renderReady(document, context) {
+        return runDetailTree(document, context.params?.runId ?? '');
+    }
+    chrome(context) {
+        return {
+            title: runDetailTitle(this.readyValue ?? {}, context.params?.runId ?? ''),
+        };
+    }
+    /** Read-only — kernel basics cover ↑↓ / Esc / q; no extra chips. */
+    actions() {
+        return [];
     }
     /**
      * F5 — the pipe's own output, and it is `string[]`.
@@ -54,17 +56,8 @@ export class RunDetailScreen extends BaseScreen {
      * path lays the body out on a cell grid of a fixed width, and a pipe has no
      * width — on run #4928 it clipped 420 transcript rows at 80 columns, losing
      * 97.7 % of a 1.34 MB captured agent transcript.
-     *
-     * This is NOT a `ScreenPresentation.lines` coming back (R3): `present()` still
-     * hands over a tree and nothing else. Both shapes are projections of the block's
-     * ONE keyed traversal (`flatRows`), so there is no second description of the
-     * screen to keep in step — see `tests/Screen/run-detail-non-tty.test.ts`, which
-     * asserts the two row for row.
      */
     renderNonInteractive(context) {
-        return runDetailRows(this.document, context.params?.runId ?? '');
-    }
-    reset() {
-        this.document = {};
+        return runDetailRows(this.readyValue ?? {}, context.params?.runId ?? '');
     }
 }

package/dist/src/Entity/run/Screen/runs.d.ts

@@ -1,9 +1,10 @@
+import type { FullScreenChrome, ListFilterBadge } from '../../../Screen/full-screen.js';
 import { ListScreen } from '../../../Screen/list-screen.js';
-import { type ScreenContext, type ScreenPresentation } from '../../../Screen/screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
 import { type RunCriteria } from '../Data/query.js';
 import { type RunPage, type RunRow } from '../Data/runs.js';
 export declare class RunsScreen extends ListScreen<RunRow, number> {
-    readonly frameId = "project-runs";
+    readonly frameId = "runs";
     readonly topTabOverlay = true;
     protected readonly table: {
         readonly noun: "run";
@@ -78,7 +79,10 @@ export declare class RunsScreen extends ListScreen<RunRow, number> {
      *  clients/test doubles, as on the ticket list. */
     protected filterRow(row: RunRow): boolean;
     protected renderLoading(): string[];
-    present(context: ScreenContext): ScreenPresentation;
+    /** Runs expose only the closed cycle — one badge, always shown (GAIA-375 A′). */
+    protected badges(): readonly ListFilterBadge[];
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
     activate(index: number, context: ScreenContext): boolean;
     select(index: number, context: ScreenContext): boolean;
     handleInput(input: string, context: ScreenContext): boolean;

package/dist/src/Entity/run/Screen/runs.js

@@ -1,10 +1,10 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
 import { ListScreen } from '../../../Screen/list-screen.js';
-import { presentation, } from '../../../Screen/screen.js';
 import { CLOSED_FILTER_VALUES, cycleValue } from '../../cycle.js';
 import { DEFAULT_RUN_CRITERIA } from '../Data/query.js';
 import { loadProjectRuns, RUN_TABLE, selectedRunTicketId, } from '../Data/runs.js';
 export class RunsScreen extends ListScreen {
-    frameId = 'project-runs';
+    frameId = 'runs';
     topTabOverlay = true;
     table = RUN_TABLE;
     topTab() {
@@ -63,55 +63,38 @@ export class RunsScreen extends ListScreen {
     renderLoading() {
         return ['Loading runs…'];
     }
-    present(context) {
-        const rows = this.rows;
-        // Standing segment: stated whenever rows are hidden, including the very
-        // first render (AC-4) — unconditional, as on the ticket list.
-        const closedSegment = this.criteria.closed === null
-            ? ''
-            : this.criteria.closed
-                ? 'closed: only'
-                : 'closed: hidden';
-        // The PAGE number, and only that; the collection's size is a different
-        // quantity, stated in its own segment by `countLabel` off the `meta.count`
-        // the page response carries (D6e). A page that offers a next page while
-        // showing few rows is correct rather than a bug: `links.next` is the
-        // end-of-collection signal, and a page can be full without being the last.
-        // The whole segment describes the LOADED page, not the requested index —
-        // that is what the `page` the value carries is for (D4); same reasoning,
-        // same shape and the same bottom-line home as the ticket list, which must
-        // not drift from this one. It is the same `loadedPage` the ARROW keys act
-        // on, so the number the operator reads and the number the keys move from
-        // are one value (R1).
-        //
-        // Built by `ListScreen` since GAIA-294, which is what makes "must not drift
-        // from the ticket list" a mechanism rather than a promise.
-        const paging = this.pagingSegments();
-        // The rows ON SCREEN and the size of the FILTERED COLLECTION, side by side:
-        // `7 of 1340 run(s)` when the server reported the total, `7 of ? run(s)`
-        // when it reported none (GAIA-292 D6c/D6d). Neither quantity replaces the
-        // other, so the row count never jumps; the total is read off the value the
-        // rows came with (D4/D4a) and from no second screen member — which is now
-        // structural rather than careful, because the server answered both from one
-        // query. Empty while the page loads (D6c), which is why the segments are
-        // joined rather than concatenated — an omitted count must not leave the line
-        // opening with a separator.
-        const count = this.countLabel();
-        return presentation(this.surface(context), {
-            selectable: rows.length,
+    /** Runs expose only the closed cycle — one badge, always shown (GAIA-375 A′). */
+    badges() {
+        if (this.criteria.closed === null) {
+            return [{ id: 'closed', label: 'x closed' }];
+        }
+        return [
+            {
+                id: 'closed',
+                label: 'x closed',
+                value: this.criteria.closed ? 'closed: only' : 'closed: hidden',
+            },
+        ];
+    }
+    chrome(context) {
+        // Count + page in header meta; ←/→ in footer actions (GAIA-375 / GAIA-292).
+        const pagingLine = [this.countLabel(), ...this.pagingSegments()]
+            .filter(Boolean)
+            .join(' · ');
+        return {
+            selectable: this.rows.length,
             selectedIndex: this.selectedIndex,
-            // The node a click on each row lands on (GAIA-340 Task 11).
             rowIds: this.rowNodeIds,
             title: `${context.project?.name ?? context.project?.slug ?? ''} · runs`,
-            meta: [
-                count,
-                closedSegment,
-                'Enter ticket · Tab tabs · x closed · Esc back',
-            ]
-                .filter(Boolean)
-                .join('  ·  '),
-            status: ` ${paging.join(' · ')} · ↑↓ select · Enter ticket · Tab tabs · x closed · Esc back · q quit `,
-        });
+            meta: pagingLine,
+        };
+    }
+    actions() {
+        return [
+            actionItem('runs-enter', 'Enter', 'ticket'),
+            actionItem('runs-tab', 'Tab', 'tabs'),
+            ...this.pagingActionItems(),
+        ];
     }
     activate(index, context) {
         const id = this.readyValue

package/dist/src/Entity/run/Screen/user-runs.d.ts

@@ -0,0 +1,79 @@
+import type { FullScreenChrome, ListFilterBadge } from '../../../Screen/full-screen.js';
+import { ListScreen } from '../../../Screen/list-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
+import { type RunPage, type RunRow } from '../Data/runs.js';
+/** Runs attributed to one user via ticket assignee (GAIA-377 D2). */
+export declare class UserRunsScreen extends ListScreen<RunRow, number> {
+    readonly frameId = "user-runs";
+    readonly topTabOverlay = true;
+    protected readonly table: {
+        readonly noun: "run";
+        readonly columns: readonly [{
+            readonly key: "run";
+            readonly label: "RUN";
+            readonly width: 8;
+            readonly fields: readonly ["drupal_internal__id"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "ticket";
+            readonly label: "TICKET";
+            readonly width: 10;
+            readonly fields: readonly ["ticket_id"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "state";
+            readonly label: "STATE";
+            readonly width: 8;
+            readonly fields: readonly ["state", "heartbeat", "claim_expires_at"];
+            readonly get: (r: RunRow, nowSeconds: number) => string;
+        }, {
+            readonly key: "phase";
+            readonly label: "PHASE";
+            readonly width: 13;
+            readonly fields: readonly ["state_at_start"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "agent";
+            readonly label: "AGENT";
+            readonly width: 8;
+            readonly fields: readonly ["agent"];
+            readonly get: (r: RunRow) => string;
+        }, {
+            readonly key: "started";
+            readonly label: "STARTED";
+            readonly width: 0;
+            readonly grow: 1;
+            readonly fields: readonly ["started_at", "created"];
+            readonly get: (r: RunRow, nowSeconds: number) => string;
+        }];
+        readonly emptyMessage: "No runs for this project.";
+    };
+    topTab(): {
+        readonly level: "user";
+        readonly tab: "runs";
+    };
+    static readonly route: {
+        id: string;
+        path: string;
+        fallback: {
+            routeId: string;
+        };
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+    };
+    readonly id: string;
+    private criteria;
+    protected tableContext(context: ScreenContext): number;
+    protected loadRows(context: ScreenContext, page: number): Promise<RunPage>;
+    protected filterRow(row: RunRow): boolean;
+    protected renderLoading(): string[];
+    protected badges(): readonly ListFilterBadge[];
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
+    activate(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+}

package/dist/src/Entity/run/Screen/user-runs.js

@@ -0,0 +1,98 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
+import { ListScreen } from '../../../Screen/list-screen.js';
+import { CLOSED_FILTER_VALUES, cycleValue } from '../../cycle.js';
+import { DEFAULT_RUN_CRITERIA } from '../Data/query.js';
+import { loadUserRuns, RUN_TABLE, selectedRunTicketId, } from '../Data/runs.js';
+/** Runs attributed to one user via ticket assignee (GAIA-377 D2). */
+export class UserRunsScreen extends ListScreen {
+    frameId = 'user-runs';
+    topTabOverlay = true;
+    table = RUN_TABLE;
+    topTab() {
+        return { level: 'user', tab: 'runs' };
+    }
+    static route = {
+        id: 'user.runs',
+        path: '/users/:userId/runs',
+        fallback: { routeId: 'users' },
+        tab: { id: 'runs', label: 'Runs', scope: 'user', order: 30 },
+    };
+    id = UserRunsScreen.route.id;
+    criteria = { ...DEFAULT_RUN_CRITERIA };
+    tableContext(context) {
+        return context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
+    }
+    loadRows(context, page) {
+        if (!context.services)
+            throw new Error('User runs requires services');
+        const userId = context.user?.id ?? context.params?.userId;
+        if (!userId)
+            throw new Error('User runs requires userId');
+        return loadUserRuns(context.services.client, userId, this.criteria, page);
+    }
+    filterRow(row) {
+        return this.criteria.closed === null || row.closed === this.criteria.closed;
+    }
+    renderLoading() {
+        return ['Loading runs…'];
+    }
+    badges() {
+        if (this.criteria.closed === null) {
+            return [{ id: 'closed', label: 'x closed' }];
+        }
+        return [
+            {
+                id: 'closed',
+                label: 'x closed',
+                value: this.criteria.closed ? 'closed: only' : 'closed: hidden',
+            },
+        ];
+    }
+    chrome(context) {
+        const name = context.user?.name ?? context.params?.userName ?? 'user';
+        const pagingLine = [this.countLabel(), ...this.pagingSegments()]
+            .filter(Boolean)
+            .join(' · ');
+        return {
+            selectable: this.rows.length,
+            selectedIndex: this.selectedIndex,
+            rowIds: this.rowNodeIds,
+            title: `${name} · runs`,
+            meta: pagingLine,
+        };
+    }
+    actions() {
+        return [
+            actionItem('user-runs-enter', 'Enter', 'ticket'),
+            actionItem('user-runs-tab', 'Tab', 'tabs'),
+            ...this.pagingActionItems(),
+        ];
+    }
+    activate(index, context) {
+        const id = this.readyValue
+            ? selectedRunTicketId(this.readyValue.rows, index)
+            : null;
+        if (!id || !context.navigate)
+            return false;
+        context.navigate('ticket.detail', { ticketId: id, tab: 'runs' });
+        return true;
+    }
+    handleInput(input, context) {
+        if (input === 'x') {
+            this.criteria = {
+                ...this.criteria,
+                closed: cycleValue(CLOSED_FILTER_VALUES, this.criteria.closed),
+            };
+            this.page = 0;
+            this.retry(context);
+            return true;
+        }
+        if (this.handlePagingInput(input, context))
+            return true;
+        if (this.handleCursorInput(input, context))
+            return true;
+        if (input === 'enter')
+            return this.activate(this.selectedIndex, context);
+        return super.handleInput(input, context);
+    }
+}