@gaia-ai/addon-gaia-ui 0.6.5 → 0.7.0

package/README.md

@@ -1,5 +1,5 @@
 # @gaia-ai/addon-gaia-ui
 
-GAIA TUI: interactive terminal UI (project dashboard, ticket list, ticket detail) as a dropsh `tui` renderer plugin.
+GAIA TUI: interactive terminal UI (dashboard, projects, tickets) as a dropsh `tui` renderer plugin.
 
 Part of the GAIA CLI. Install the meta package `@gaia-ai/gaia` to get the `gaia` CLI with all addons. Source: https://git.key-tec.de/keytec/gaia (gaia-cli/).

package/dist/src/Component/section-list/index.d.ts

@@ -7,3 +7,40 @@ export declare function flattenSections(sections: Section[]): {
     lines: string[];
     boldRows: Set<number>;
 };
+/**
+ * One collapsible entry: a caret header row plus the rows shown in each state.
+ *
+ * GAIA-255 D2: the Comments tab's collapse/expand interaction and the Overview
+ * tab's Description are ONE primitive rather than two renderers that happen to
+ * agree — AC-2 asks for "the same expand interaction the Comments tab offers",
+ * and structural sharing is the only form of that claim a test can hold.
+ */
+export interface ExpandableEntry {
+    /** The header row's text, after the caret. */
+    header: string;
+    /** Rows shown while collapsed (indented like the expanded body). */
+    collapsed: string[];
+    /** Rows shown while expanded. */
+    expanded: string[];
+}
+/** The rendered rows of a list of expandable entries. */
+export interface ExpandableView {
+    lines: string[];
+    boldRows: Set<number>;
+    /** `headerRows[i]` is the row index of entry i's header — the selection map. */
+    headerRows: number[];
+    selectable: number;
+}
+/**
+ * Flatten expandable entries: one caret header row per entry (`▸` collapsed,
+ * `▾` expanded) followed by that state's rows. `headerRows[i]` is entry i's
+ * header row, which is both the highlight target and the click map (the rows are
+ * NOT uniformly spaced — an expanded entry appends its body).
+ *
+ * Zero entries render `emptyMessage` and nothing selectable, so an empty list is
+ * an explicit statement rather than a blank screen.
+ */
+export declare function flattenExpandable(entries: ExpandableEntry[], { expanded, emptyMessage, }: {
+    expanded?: ReadonlySet<number>;
+    emptyMessage: string;
+}): ExpandableView;

package/dist/src/Component/section-list/index.js

@@ -1,3 +1,25 @@
+/**
+ * Append one body row, applying the MINIMAL MARKDOWN rule: an ATX heading
+ * (`#`…`######`) renders as bold with the markers stripped — the same rule a
+ * section heading follows, styled after fit(). Bullets and code fences stay raw
+ * by design (explicit v1 decision).
+ *
+ * Extracted so `flattenSections` and `flattenExpandable` cannot answer "what does
+ * a `## Context` line render as" differently: the Description block is rendered
+ * by BOTH (flat on the piped render, expandable on the Overview tab), and a rule
+ * living in only one of them would make the same body look different depending on
+ * which renderer reached it.
+ */
+function pushRow(lines, boldRows, line) {
+    const md = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (md) {
+        boldRows.add(lines.length);
+        lines.push(md[2] ?? '');
+    }
+    else {
+        lines.push(line);
+    }
+}
 // Flatten `{heading, lines}` sections into plain rows plus the indices that are
 // bold (section headings + markdown ATX headings). Headings carry NO ANSI here —
 // the draw step applies bold after fit(), so sanitizeDisplay never sees (and
@@ -8,20 +30,45 @@ export function flattenSections(sections) {
     for (const section of sections) {
         boldRows.add(lines.length);
         lines.push(section.heading);
-        for (const line of section.lines) {
-            // Minimal markdown: an ATX heading (`#`…`######`) renders as bold with the
-            // markers stripped — same rule as a section heading, styled after fit().
-            // Bullets and code fences stay raw by design (explicit v1 decision).
-            const md = /^(#{1,6})\s+(.*)$/.exec(line);
-            if (md) {
-                boldRows.add(lines.length);
-                lines.push(md[2] ?? '');
-            }
-            else {
-                lines.push(line);
-            }
-        }
+        for (const line of section.lines)
+            pushRow(lines, boldRows, line);
         lines.push('');
     }
     return { lines, boldRows };
 }
+/**
+ * Flatten expandable entries: one caret header row per entry (`▸` collapsed,
+ * `▾` expanded) followed by that state's rows. `headerRows[i]` is entry i's
+ * header row, which is both the highlight target and the click map (the rows are
+ * NOT uniformly spaced — an expanded entry appends its body).
+ *
+ * Zero entries render `emptyMessage` and nothing selectable, so an empty list is
+ * an explicit statement rather than a blank screen.
+ */
+export function flattenExpandable(entries, { expanded = new Set(), emptyMessage,
+// GAIA-255 AC-11 review: `ReadonlySet` because the render path is handed ONE
+// shared empty set for every not-yet-expanded tab (`expandedFor`) — growing
+// it here would leak one tab's expansion into all the others. The renderer
+// only ever calls `.has()`, so the narrowing costs it nothing.
+ }) {
+    if (!entries.length) {
+        return {
+            lines: [emptyMessage],
+            boldRows: new Set(),
+            headerRows: [],
+            selectable: 0,
+        };
+    }
+    const lines = [];
+    const boldRows = new Set();
+    const headerRows = [];
+    entries.forEach((entry, i) => {
+        headerRows.push(lines.length);
+        boldRows.add(lines.length);
+        lines.push(`${expanded.has(i) ? '▾' : '▸'} ${entry.header}`);
+        for (const line of expanded.has(i) ? entry.expanded : entry.collapsed) {
+            pushRow(lines, boldRows, line);
+        }
+    });
+    return { lines, boldRows, headerRows, selectable: entries.length };
+}

package/dist/src/Component/stats-panel/index.d.ts

@@ -0,0 +1,49 @@
+/** A filled bar cell. U+2588 FULL BLOCK. */
+export declare const BAR_FULL = "\u2588";
+/** An empty bar cell. U+2591 LIGHT SHADE. */
+export declare const BAR_EMPTY = "\u2591";
+/**
+ * The bar's width in display columns.
+ *
+ * `█`/`░` are narrow per `lib/width-table.ts` — neither is in `WIDE_RANGES` — so
+ * the row geometry GAIA-241's hit testing depends on is unaffected. They are NOT
+ * ASCII, though, and both are East-Asian-AMBIGUOUS: a terminal configured
+ * ambiguous-as-wide (common in CJK setups) renders them two columns and shifts
+ * every number column at runtime while every test here stays green, because the
+ * width table deliberately treats Ambiguous as narrow (the frame's box-drawing
+ * characters depend on that). Accepted rather than mitigated — spec R9. If it
+ * ever bites, the fix is an ASCII bar glyph, never a width-table change.
+ */
+export declare const BAR_WIDTH = 20;
+/** One row of a block: a name and its counts, most-significant number last. */
+export interface StatsPanelRow {
+    label: string;
+    /**
+     * The counts to print, in column order. The LAST one is what the bar
+     * measures — for a breakdown row that is the month, so a row whose day count
+     * is zero still shows the activity it actually had.
+     */
+    numbers: number[];
+}
+export interface StatsPanelOptions {
+    /**
+     * Column titles, printed as a header row above the numbers. Omitted for a
+     * single-number block, where the label already says which window it is.
+     *
+     * The mock in spec D11 hangs these titles off the block's HEADING line; they
+     * are their own row here because the heading belongs to `flattenSections`,
+     * which owns the bold-row set. Same information, one row lower, and the two
+     * components keep their boundary.
+     */
+    columns?: readonly string[] | undefined;
+    /** What to render instead of rows when there are none (spec R7). */
+    emptyMessage?: string | undefined;
+}
+/**
+ * One block's body rows: an optional column header, then one row per entry.
+ *
+ * Every column is measured with `displayWidth` (through `pad`/`padNumber`), so a
+ * wide-character label cannot shift the numbers out of alignment — the failure
+ * that makes a table of counts unreadable exactly when the data is interesting.
+ */
+export declare function statsPanelRows(rows: readonly StatsPanelRow[], { columns, emptyMessage }?: StatsPanelOptions): string[];

package/dist/src/Component/stats-panel/index.js

@@ -0,0 +1,114 @@
+import { pad } from '../../lib/format.js';
+import { displayWidth } from '../../lib/width.js';
+// GAIA-256 spec D11 — the Dashboard's `/usage`-style bar rows.
+//
+// A SHARED component (the third in `src/Component/`), and it earns that place by
+// carrying no entity vocabulary at all: it takes `{ label, numbers }` and draws
+// bars. Nothing here knows a ticket from a run from a project — which is exactly
+// what G4 asserts, and why the Dashboard can render four different blocks from
+// one function.
+//
+// It produces the ROWS OF ONE BLOCK. Stacking blocks under bold headings is
+// `flattenSections`' job (`Component/section-list`), unchanged: this component
+// only fills a block's body.
+/** A filled bar cell. U+2588 FULL BLOCK. */
+export const BAR_FULL = '█';
+/** An empty bar cell. U+2591 LIGHT SHADE. */
+export const BAR_EMPTY = '░';
+/**
+ * The bar's width in display columns.
+ *
+ * `█`/`░` are narrow per `lib/width-table.ts` — neither is in `WIDE_RANGES` — so
+ * the row geometry GAIA-241's hit testing depends on is unaffected. They are NOT
+ * ASCII, though, and both are East-Asian-AMBIGUOUS: a terminal configured
+ * ambiguous-as-wide (common in CJK setups) renders them two columns and shifts
+ * every number column at runtime while every test here stays green, because the
+ * width table deliberately treats Ambiguous as narrow (the frame's box-drawing
+ * characters depend on that). Accepted rather than mitigated — spec R9. If it
+ * ever bites, the fix is an ASCII bar glyph, never a width-table change.
+ */
+export const BAR_WIDTH = 20;
+/**
+ * The label column, in display columns: 26 for the text plus {@link LABEL_GAP}.
+ *
+ * The text budget is wide enough for the longest label the Dashboard actually
+ * builds: a breakdown row suffixes its entity type (`gaia · tickets`), the
+ * unattributed bucket's `— unattributed · tickets` is 24 columns and a real
+ * project name reaches 26 (`gaia-e2e-project · tickets`). At 18 that suffix was
+ * cut to `— unattributed · t…`, which silently made the two entity types
+ * indistinguishable in exactly the row where attribution is already unclear.
+ */
+const LABEL_WIDTH = 27;
+/**
+ * Columns of the label field reserved as the gap before the bar.
+ *
+ * Load-bearing, not decoration. `pad` fills a label to exactly `LABEL_WIDTH`, so
+ * a label of precisely that width left NO separator and the row rendered
+ * `gaia-e2e-project · tickets████████` — a real project name, at exactly 26
+ * columns. A truncated label collided the same way, ending in `…` against the
+ * bar. Every fixture in the tests was shorter, which is why the suite was green
+ * while the screen was wrong; the gap is part of the geometry now so the label
+ * length cannot decide whether it exists.
+ *
+ * It is ADDED to the field rather than taken out of it: the 26 columns above are
+ * a content budget with a stated reason, and spending one of them on the gap
+ * would cut `gaia-e2e-project · tickets` to `gaia-e2e-project · ticke…` — losing
+ * exactly the entity-type suffix that tells the two rows of a project apart.
+ */
+const LABEL_GAP = 1;
+/** One number column, in display columns. */
+const NUMBER_WIDTH = 8;
+/** The indent every row of a block carries, matching the other body renderers. */
+const INDENT = '  ';
+/** `value` right-aligned to `width` DISPLAY columns — the number columns' rule. */
+function padNumber(value, width) {
+    const gap = Math.max(0, width - displayWidth(value));
+    return ' '.repeat(gap) + value;
+}
+/**
+ * The bar for `value` within a group whose largest bar value is `max`.
+ *
+ * Scaled RELATIVE TO THE LARGEST VALUE IN ITS OWN GROUP, not to a limit. This is
+ * the one place the `/usage` analogy does not carry: `/usage` measures against a
+ * quota, and there is no quota here — so a full bar means "the biggest of these",
+ * never "100 %". An all-zero group has no maximum to scale by and renders empty
+ * rather than dividing by zero.
+ */
+function bar(value, max) {
+    const filled = max > 0
+        ? Math.max(0, Math.min(BAR_WIDTH, Math.round((value / max) * BAR_WIDTH)))
+        : 0;
+    return BAR_FULL.repeat(filled) + BAR_EMPTY.repeat(BAR_WIDTH - filled);
+}
+/**
+ * One block's body rows: an optional column header, then one row per entry.
+ *
+ * Every column is measured with `displayWidth` (through `pad`/`padNumber`), so a
+ * wide-character label cannot shift the numbers out of alignment — the failure
+ * that makes a table of counts unreadable exactly when the data is interesting.
+ */
+export function statsPanelRows(rows, { columns, emptyMessage } = {}) {
+    if (rows.length === 0) {
+        return emptyMessage === undefined ? [] : [`${INDENT}${emptyMessage}`];
+    }
+    const barValue = (row) => row.numbers.at(-1) ?? 0;
+    const max = Math.max(...rows.map(barValue));
+    const out = [];
+    if (columns && columns.length > 0) {
+        out.push(INDENT +
+            pad('', LABEL_WIDTH) +
+            ' '.repeat(BAR_WIDTH) +
+            columns.map((c) => padNumber(c, NUMBER_WIDTH)).join(''));
+    }
+    for (const row of rows) {
+        out.push(INDENT +
+            // Padded to the field width MINUS the gap, then the gap: the label
+            // column stays `LABEL_WIDTH` wide either way, so the header row above
+            // and every bar below still line up.
+            pad(row.label, LABEL_WIDTH - LABEL_GAP) +
+            ' '.repeat(LABEL_GAP) +
+            bar(barValue(row), max) +
+            row.numbers.map((n) => padNumber(String(n), NUMBER_WIDTH)).join(''));
+    }
+    return out;
+}

package/dist/src/Component/top-tabs/index.d.ts

@@ -5,11 +5,17 @@ export interface TopTab {
 }
 /** The root level: what there is before a project is chosen. */
 export declare const ROOT_TABS: readonly [{
+    readonly id: "dashboard";
+    readonly label: "Dashboard";
+}, {
     readonly id: "projects";
     readonly label: "Projects";
 }];
 /** The project level: the tabs of an opened project. */
 export declare const PROJECT_TABS: readonly [{
+    readonly id: "dashboard";
+    readonly label: "Dashboard";
+}, {
     readonly id: "tickets";
     readonly label: "Tickets";
 }, {
@@ -22,10 +28,16 @@ export declare const PROJECT_TABS: readonly [{
 /** The tab bars, keyed by level — the one place a level is named. */
 export declare const TAB_LEVELS: {
     readonly root: readonly [{
+        readonly id: "dashboard";
+        readonly label: "Dashboard";
+    }, {
         readonly id: "projects";
         readonly label: "Projects";
     }];
     readonly project: readonly [{
+        readonly id: "dashboard";
+        readonly label: "Dashboard";
+    }, {
         readonly id: "tickets";
         readonly label: "Tickets";
     }, {
@@ -75,17 +87,6 @@ export declare function topTabBar<L extends TabLevel>(level: L, activeId: TabIdO
  * not ask the compiler to correlate two independently narrowed properties.
  */
 export declare function tabBarFor(location: TabLocation): string;
-/**
- * Which level a tab id belongs to, as a whole {@link TabLocation} — or `null`
- * for an id no level declares.
- *
- * The cast is the one place the level→id pairing is asserted rather than
- * checked, and it is sound by construction: the id was just found **in that
- * level's own registry**, which is exactly what `TabLocation` requires.
- * TypeScript cannot see that through the `Object.keys` loop, so it is stated
- * here once, behind a checked lookup, instead of at every call site.
- */
-export declare function locateTab(tab: TopTabId): TabLocation | null;
 /** Where one tab sits inside the bar: `[start, end)` in display columns from the
  *  bar's own first column. */
 export interface TopTabSpan<Id extends string = TopTabId> {

package/dist/src/Component/top-tabs/index.js

@@ -3,8 +3,9 @@ import { displayWidth } from '../../lib/width.js';
 // the top-level tabs are written. Navigation has THREE levels, and every screen
 // shows exactly ONE tab bar: the one of its own level.
 //
-//   root     dashboard, project-picker            → Projects
-//   project  project, ticket-agents, project-runs → Tickets · Ticket-Agents · Runs
+//   root     dashboard, projects, project-picker  → Dashboard · Projects
+//   project  dashboard, project, ticket-agents,   → Dashboard · Tickets ·
+//            project-runs                           Ticket-Agents · Runs
 //   ticket   ticket                               → the DETAIL tabs, drawn as the
 //                                                    header box's meta row, so no
 //                                                    top-level bar at all
@@ -14,6 +15,21 @@ import { displayWidth } from '../../lib/width.js';
 // (GAIA-192) — all three project-scoped, which is why they sit on the project
 // level and not on the root one.
 //
+// GAIA-256 spec D2: `dashboard` is declared on BOTH levels, on purpose. There is
+// ONE Dashboard screen — the root one and the project one are the same screen
+// with its project filter unset or set, and its LEVEL follows that same bit, so
+// the bar and the filter can never disagree: they read one value.
+//
+// That is why tab ids are no longer globally unique, and why nothing here
+// requires them to be. The requirement was never a property of the model — every
+// function in this file is already level-parameterised (`topTabBar(level, id)`,
+// `topTabSpans(level, id)`, `tabBarFor(location)`, `TabIdOf<L>`). It was a
+// property of ONE function, the level-blind `locateTab`, which walked the levels
+// in key order and would now resolve the project level's `dashboard` to the ROOT
+// location. `gotoTopTab` was its only caller, and it only ever moves within one
+// level — the bar you Tab through or click IS the current level's bar — so it
+// pairs the target with `here.level` directly and `locateTab` is deleted.
+//
 // Only tabs that are actually navigable are listed. A planned screen (`Users` on
 // the root level, `Conductors` on the project level) arrives with its own ticket
 // and adds its entry here then — a tab drawn before its screen exists would
@@ -27,10 +43,12 @@ import { displayWidth } from '../../lib/width.js';
 // `string`, taking the compile-time check with it.
 /** The root level: what there is before a project is chosen. */
 export const ROOT_TABS = [
+    { id: 'dashboard', label: 'Dashboard' },
     { id: 'projects', label: 'Projects' },
 ];
 /** The project level: the tabs of an opened project. */
 export const PROJECT_TABS = [
+    { id: 'dashboard', label: 'Dashboard' },
     { id: 'tickets', label: 'Tickets' },
     { id: 'ticket-agents', label: 'Ticket-Agents' },
     { id: 'runs', label: 'Runs' },
@@ -65,25 +83,6 @@ export function topTabBar(level, activeId) {
 export function tabBarFor(location) {
     return renderBar(TAB_LEVELS[location.level], location.tab);
 }
-/**
- * Which level a tab id belongs to, as a whole {@link TabLocation} — or `null`
- * for an id no level declares.
- *
- * The cast is the one place the level→id pairing is asserted rather than
- * checked, and it is sound by construction: the id was just found **in that
- * level's own registry**, which is exactly what `TabLocation` requires.
- * TypeScript cannot see that through the `Object.keys` loop, so it is stated
- * here once, behind a checked lookup, instead of at every call site.
- */
-export function locateTab(tab) {
-    for (const level of Object.keys(TAB_LEVELS)) {
-        const tabs = TAB_LEVELS[level];
-        if (tabs.some((t) => t.id === tab)) {
-            return { level, tab };
-        }
-    }
-    return null;
-}
 const renderSpans = (tabs, activeId) => {
     const spans = [];
     let start = 0;

package/dist/src/Entity/conductor/Data/conductors.d.ts

@@ -1,5 +1,5 @@
 import type { DropshClient } from '../../../types.js';
-import { type OptionClients } from '../../transport.js';
+import { type ListOutcome, type OptionClients } from '../../transport.js';
 /** One conductor of the control plane, as this renderer needs it. */
 export interface Conductor {
     id: string;
@@ -12,8 +12,14 @@ export interface Conductor {
     /** The conductor's project, `null` when unlinked. */
     projectId: string | null;
 }
-/** The conductor collection through one client, in server order. */
-export declare const listConductors: (client: DropshClient) => Promise<Conductor[]>;
+/**
+ * The conductor collection through one client, in server order.
+ *
+ * Yields the OUTCOME rather than a swallowed array (GAIA-257 D4) — see the same
+ * note on `listUsers`. `listConductorsPreferringWrite` keeps the swallowing
+ * contract, because it already answers a failure by falling back.
+ */
+export declare const listConductors: (client: DropshClient) => Promise<ListOutcome<Conductor>>;
 /**
  * The same collection read through the WRITE client where there is one — still just
  * reading, but the write scope is the one that decides what a write may reference,

package/dist/src/Entity/conductor/Data/conductors.js

@@ -1,4 +1,4 @@
-import { list, listPreferringWrite, } from '../../transport.js';
+import { listOutcome, listPreferringWrite, } from '../../transport.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const toConductor = (r) => ({
     id: r.id,
@@ -7,8 +7,14 @@ const toConductor = (r) => ({
     status: str(r.attr('status')),
     projectId: r.rel('project_id'),
 });
-/** The conductor collection through one client, in server order. */
-export const listConductors = (client) => list(client, 'gaia_conductor', toConductor);
+/**
+ * The conductor collection through one client, in server order.
+ *
+ * Yields the OUTCOME rather than a swallowed array (GAIA-257 D4) — see the same
+ * note on `listUsers`. `listConductorsPreferringWrite` keeps the swallowing
+ * contract, because it already answers a failure by falling back.
+ */
+export const listConductors = (client) => listOutcome(client, 'gaia_conductor', toConductor);
 /**
  * The same collection read through the WRITE client where there is one — still just
  * reading, but the write scope is the one that decides what a write may reference,

package/dist/src/Entity/project/Component/project-list/index.d.ts

@@ -0,0 +1,8 @@
+/** The minimum shape a project row needs to render. */
+export interface ProjectRowInput {
+    project: string;
+    derivedStatus: string;
+    ageLabel: string;
+}
+/** One line per project: name, derived status, relative age. */
+export declare function projectRows(projects: ProjectRowInput[]): string[];

package/dist/src/Entity/project/Component/project-list/index.js

@@ -0,0 +1,7 @@
+import { pad } from '../../../../lib/format.js';
+/** One line per project: name, derived status, relative age. */
+export function projectRows(projects) {
+    if (projects.length === 0)
+        return ['No projects.'];
+    return projects.map((p) => `${pad(p.project, 24)} ${pad(p.derivedStatus, 14)} ${p.ageLabel}`);
+}

package/dist/src/Entity/project/Data/projects.d.ts

@@ -1,21 +1,21 @@
 import type { DropshClient } from '../../../types.js';
 import { type ConductorStatus } from '../../conductor/Data/liveness.js';
-/** A derived dashboard row: one distinct project + its liveliest conductor. */
-export interface DashboardProject {
+/** A derived project row: one distinct project + its liveliest conductor. */
+export interface ProjectRow {
     project: string;
     derivedStatus: ConductorStatus;
     lastSeen: number | null;
     ageLabel: string;
 }
 /**
- * Resolve the dashboard's project rows straight from the control plane: list the
+ * Resolve the projects screen's rows straight from the control plane: list the
  * `gaia_conductor` entities (read is owner-gated, so this is already scoped to
  * the current user's conductors — no local registry needed), sideload their
  * `project_id`, group by project name, and report each project's liveliest
  * conductor (running > stale > offline). Everything is a Drupal entity read
- * through `services.client` (AC-5); the dashboard itself stays a screen/route.
+ * through `services.client` (AC-5); the screen itself stays a screen/route.
  */
-export declare function loadDashboardProjects({ client, nowSeconds, }: {
+export declare function loadProjectRows({ client, nowSeconds, }: {
     client: DropshClient;
     nowSeconds: () => number;
-}): Promise<DashboardProject[]>;
+}): Promise<ProjectRow[]>;

package/dist/src/Entity/project/Data/projects.js

@@ -28,14 +28,14 @@ const STATUS_RANK = {
     'registry-only': 3,
 };
 /**
- * Resolve the dashboard's project rows straight from the control plane: list the
+ * Resolve the projects screen's rows straight from the control plane: list the
  * `gaia_conductor` entities (read is owner-gated, so this is already scoped to
  * the current user's conductors — no local registry needed), sideload their
  * `project_id`, group by project name, and report each project's liveliest
  * conductor (running > stale > offline). Everything is a Drupal entity read
- * through `services.client` (AC-5); the dashboard itself stays a screen/route.
+ * through `services.client` (AC-5); the screen itself stays a screen/route.
  */
-export async function loadDashboardProjects({ client, nowSeconds, }) {
+export async function loadProjectRows({ client, nowSeconds, }) {
     const params = new DrupalJsonApiParams().addInclude(['project_id']);
     let doc;
     try {
@@ -57,7 +57,7 @@ export async function loadDashboardProjects({ client, nowSeconds, }) {
         const a = c.attributes ?? {};
         const projectId = singleRelId(c.relationships?.project_id);
         const project = projectId ? projectNameById.get(projectId) : undefined;
-        // A conductor whose project cannot be resolved is not a dashboard row.
+        // A conductor whose project cannot be resolved is not a project row.
         if (!project)
             continue;
         const lastSeen = toEpochSeconds(a.last_seen ?? null);

package/dist/src/Entity/run/Component/run-detail/index.d.ts

@@ -0,0 +1,17 @@
+import type { Section } from '../../../../Component/section-list/index.js';
+import type { JsonApiResource, TicketDetailDocument } from '../../../../types.js';
+/** The sideloaded `gaia_run` with this id, or undefined. */
+export declare function runResource(document: TicketDetailDocument, runId: string | null | undefined): JsonApiResource | undefined;
+/** `#<id> · <ticket> · <state>` — the run screen's header-box title row. */
+export declare function runDetailTitle(document: TicketDetailDocument, runId: string | null | undefined): string;
+/**
+ * The run's sections, in the order the screen draws them. An unresolvable run
+ * yields ONE section saying so, rather than an empty screen that looks like a
+ * failed render.
+ */
+export declare function runDetailSections(document: TicketDetailDocument, runId: string | null | undefined): Section[];
+/** The run block flattened — the screen's body, and the piped render (D7). */
+export declare function runDetailLines(document: TicketDetailDocument, runId: string | null | undefined): {
+    lines: string[];
+    boldRows: Set<number>;
+};