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

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

@@ -3,6 +3,121 @@ export interface TopTab {
     id: string;
     label: string;
 }
-export declare const TOP_TABS: TopTab[];
-/** The top tab bar as a single row; the active tab is bracketed. */
-export declare function topTabBar(activeId: string): string;
+/** 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";
+}, {
+    readonly id: "ticket-agents";
+    readonly label: "Ticket-Agents";
+}, {
+    readonly id: "runs";
+    readonly label: "Runs";
+}];
+/** 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";
+    }, {
+        readonly id: "ticket-agents";
+        readonly label: "Ticket-Agents";
+    }, {
+        readonly id: "runs";
+        readonly label: "Runs";
+    }];
+};
+/** The name of a level that carries a top-level tab bar. */
+export type TabLevel = keyof typeof TAB_LEVELS;
+/** The ids of one level's tabs, derived from {@link TAB_LEVELS}. */
+export type TabIdOf<L extends TabLevel> = (typeof TAB_LEVELS)[L][number]['id'];
+/**
+ * The id of any top-level tab, derived — never re-listed. Before GAIA-239 this
+ * union was hand-written in `tui-kernel.ts` alongside a third hardcoded copy of
+ * the same ids for the Tab cycle order; the three could drift silently.
+ */
+export type TopTabId = {
+    [L in TabLevel]: TabIdOf<L>;
+}[TabLevel];
+/**
+ * Where a screen sits in the navigation: which bar it draws, and which tab of
+ * that bar is its own. A discriminated union over the levels, so a location can
+ * never pair one level's name with another level's tab id.
+ */
+export type TabLocation = {
+    [L in TabLevel]: {
+        level: L;
+        tab: TabIdOf<L>;
+    };
+}[TabLevel];
+/**
+ * One level's tab bar as a single row; the active tab is bracketed.
+ *
+ * The level is part of the signature on purpose: it is what keeps the id checked
+ * at compile time now that there is more than one bar. `topTabBar('root', 'runs')`
+ * is a TS2345 naming the root level's valid ids — not a bar that silently
+ * brackets nothing.
+ */
+export declare function topTabBar<L extends TabLevel>(level: L, activeId: TabIdOf<L>): string;
+/**
+ * The same bar, for a caller holding a whole {@link TabLocation} rather than a
+ * literal level. The pairing was already checked when the location was built, so
+ * this needs no second check — and unlike `topTabBar(loc.level, loc.tab)` it does
+ * not ask the compiler to correlate two independently narrowed properties.
+ */
+export declare function tabBarFor(location: TabLocation): string;
+/** 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> {
+    id: Id;
+    start: number;
+    end: number;
+}
+/**
+ * One level's own hit map, built from the SAME `segment`/`SEPARATOR` that level's
+ * rendered bar is joined from — so the layout and the click mapping are two
+ * readings of one expression and cannot drift apart. That is the argument
+ * `lib/hit-test.ts` makes for the body rows, applied to a column axis.
+ *
+ * Offsets are display columns, which is the unit a mouse report carries. For the
+ * current ASCII labels that coincides with string offsets, which is what lets
+ * the test slice `topTabBar()` with a span and compare.
+ *
+ * GAIA-239: the LEVEL is part of the signature, exactly as it is for
+ * {@link topTabBar}, and for the same reason twice over. GAIA-241 shipped one
+ * `topTabSpans(activeId)` over the single flat bar; read level-blind it would
+ * publish the project bar's three spans on the root screen too, so a click at
+ * the column where `Ticket-Agents` used to sit would open a tab that screen does
+ * not draw — the very defect this ticket removes, arriving through the mouse.
+ * A map and a bar of two different levels is now a TS2345, not a silent
+ * mis-click.
+ */
+export declare function topTabSpans<L extends TabLevel>(level: L, activeId: TabIdOf<L>): TopTabSpan<TabIdOf<L>>[];
+/**
+ * The same hit map, for a caller holding a whole {@link TabLocation} — the
+ * companion of {@link tabBarFor}, and the pairing it needs was already checked
+ * when the location was built. Keeping the two in step is what makes "the bar you
+ * see is the bar you click" true by construction: both read `location`.
+ */
+export declare function tabSpansFor(location: TabLocation): TopTabSpan[];

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

@@ -1,13 +1,128 @@
-// The top-level navigation tabs. `tickets` is the project/ticket drill-down;
-// `ticket-agents` is the managed create-agent list (GAIA-190); `runs` is the
-// project-scoped run overview (GAIA-192). `conductors` is a planned follow-up
-// (tracked separately) — not wired yet.
-export const TOP_TABS = [
+import { displayWidth } from '../../lib/width.js';
+// GAIA-239: THE registry — the single place the set, the order and the labels of
+// 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, 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
+//
+// `tickets` is the project/ticket drill-down; `ticket-agents` is the managed
+// create-agent list (GAIA-190); `runs` is the project-scoped run overview
+// (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
+// advertise navigation the operator cannot take, which is the very defect
+// GAIA-239 removes.
+//
+// `as const satisfies` is load-bearing on both halves: `satisfies` still
+// shape-checks every entry against `TopTab`, while `as const` keeps the literal
+// ids so the id unions below can be DERIVED from them. A plain `: TopTab[]`
+// annotation would widen `id` to `string` and the derivation would collapse to
+// `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' },
 ];
-/** The top tab bar as a single row; the active tab is bracketed. */
-export function topTabBar(activeId) {
-    return TOP_TABS.map((t) => t.id === activeId ? `[${t.label}]` : ` ${t.label} `).join('  ');
+/** The tab bars, keyed by level — the one place a level is named. */
+export const TAB_LEVELS = {
+    root: ROOT_TABS,
+    project: PROJECT_TABS,
+};
+/** What joins two tabs in the rendered bar — part of neither tab's span. */
+const SEPARATOR = '  ';
+/** One tab's rendered segment: bracketed when active, space-padded otherwise. */
+const segment = (tab, activeId) => tab.id === activeId ? `[${tab.label}]` : ` ${tab.label} `;
+const renderBar = (tabs, activeId) => tabs.map((t) => segment(t, activeId)).join(SEPARATOR);
+/**
+ * One level's tab bar as a single row; the active tab is bracketed.
+ *
+ * The level is part of the signature on purpose: it is what keeps the id checked
+ * at compile time now that there is more than one bar. `topTabBar('root', 'runs')`
+ * is a TS2345 naming the root level's valid ids — not a bar that silently
+ * brackets nothing.
+ */
+export function topTabBar(level, activeId) {
+    return renderBar(TAB_LEVELS[level], activeId);
+}
+/**
+ * The same bar, for a caller holding a whole {@link TabLocation} rather than a
+ * literal level. The pairing was already checked when the location was built, so
+ * this needs no second check — and unlike `topTabBar(loc.level, loc.tab)` it does
+ * not ask the compiler to correlate two independently narrowed properties.
+ */
+export function tabBarFor(location) {
+    return renderBar(TAB_LEVELS[location.level], location.tab);
+}
+const renderSpans = (tabs, activeId) => {
+    const spans = [];
+    let start = 0;
+    tabs.forEach((tab, index) => {
+        if (index > 0)
+            start += displayWidth(SEPARATOR);
+        const width = displayWidth(segment(tab, activeId));
+        spans.push({ id: tab.id, start, end: start + width });
+        start += width;
+    });
+    return spans;
+};
+/**
+ * One level's own hit map, built from the SAME `segment`/`SEPARATOR` that level's
+ * rendered bar is joined from — so the layout and the click mapping are two
+ * readings of one expression and cannot drift apart. That is the argument
+ * `lib/hit-test.ts` makes for the body rows, applied to a column axis.
+ *
+ * Offsets are display columns, which is the unit a mouse report carries. For the
+ * current ASCII labels that coincides with string offsets, which is what lets
+ * the test slice `topTabBar()` with a span and compare.
+ *
+ * GAIA-239: the LEVEL is part of the signature, exactly as it is for
+ * {@link topTabBar}, and for the same reason twice over. GAIA-241 shipped one
+ * `topTabSpans(activeId)` over the single flat bar; read level-blind it would
+ * publish the project bar's three spans on the root screen too, so a click at
+ * the column where `Ticket-Agents` used to sit would open a tab that screen does
+ * not draw — the very defect this ticket removes, arriving through the mouse.
+ * A map and a bar of two different levels is now a TS2345, not a silent
+ * mis-click.
+ */
+export function topTabSpans(level, activeId) {
+    return renderSpans(TAB_LEVELS[level], activeId);
+}
+/**
+ * The same hit map, for a caller holding a whole {@link TabLocation} — the
+ * companion of {@link tabBarFor}, and the pairing it needs was already checked
+ * when the location was built. Keeping the two in step is what makes "the bar you
+ * see is the bar you click" true by construction: both read `location`.
+ */
+export function tabSpansFor(location) {
+    return renderSpans(TAB_LEVELS[location.level], location.tab);
 }

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

@@ -0,0 +1,28 @@
+import type { DropshClient } from '../../../types.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;
+    /** Never empty — the uuid is the last fallback, so nothing renders as blank. */
+    label: string;
+    /** The machine the conductor runs on. */
+    machineId: string | undefined;
+    /** Liveness, as the control plane reports it. */
+    status: string | undefined;
+    /** The conductor's project, `null` when unlinked. */
+    projectId: string | null;
+}
+/**
+ * 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,
+ * and `pm` sees the FULL conductor set where `session` sees a subset.
+ */
+export declare const listConductorsPreferringWrite: (clients: OptionClients) => Promise<Conductor[]>;

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

@@ -0,0 +1,23 @@
+import { listOutcome, listPreferringWrite, } from '../../transport.js';
+const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
+const toConductor = (r) => ({
+    id: r.id,
+    label: str(r.attr('label')) ?? str(r.attr('machine_id')) ?? r.id,
+    machineId: str(r.attr('machine_id')),
+    status: str(r.attr('status')),
+    projectId: r.rel('project_id'),
+});
+/**
+ * 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,
+ * and `pm` sees the FULL conductor set where `session` sees a subset.
+ */
+export const listConductorsPreferringWrite = (clients) => listPreferringWrite(clients, 'gaia_conductor', toConductor);

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

@@ -0,0 +1,10 @@
+/** The derived liveness state of a conductor. */
+export type ConductorStatus = 'running' | 'stale' | 'offline' | 'registry-only';
+/** The raw liveness inputs derived from a `gaia_conductor` record. */
+export interface ConductorInput {
+    present?: boolean;
+    status?: string | null;
+    lastSeen?: number | null;
+    leaseExpiresAt?: number | null;
+}
+export declare function deriveConductorStatus(conductor: ConductorInput, nowSeconds: number): ConductorStatus;

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

@@ -0,0 +1,25 @@
+// Conductor liveness derivation. Mirrors the server-side ConductorDeriver
+// (web/modules/custom/gaia_core/modules/gaia_dashboard/src/Dashboard/ConductorDeriver.php)
+// and the CLI `classify()` in gaia-cli/conductor/src/commands/conductor.ts:
+// no gaia_conductor record → registry-only; status 'offline' → offline; else
+// stale when last_seen older than 600s OR the lease has expired; else running.
+const STALE_WINDOW_SECONDS = 600;
+export function deriveConductorStatus(conductor, nowSeconds) {
+    if (!conductor?.present)
+        return 'registry-only';
+    if (conductor.status === 'offline')
+        return 'offline';
+    if (conductor.lastSeen == null)
+        return 'stale';
+    if (nowSeconds - conductor.lastSeen > STALE_WINDOW_SECONDS)
+        return 'stale';
+    if (conductor.leaseExpiresAt != null &&
+        conductor.leaseExpiresAt < nowSeconds) {
+        return 'stale';
+    }
+    return 'running';
+}
+// `humanizeAge` moved to `lib/format.ts` (GAIA-236, entity-slice Phase 0): it is a
+// generic relative-time formatter with no conductor vocabulary, and keeping it here
+// is what made `Component/comment-item` and `Deriver/run-status` import a CONDUCTOR
+// module. Its test moved with it, to `tests/lib/format.test.ts`.

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

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

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

@@ -0,0 +1,7 @@
+import { pad } from '../../../../lib/format.js';
+/** One line per project: name, derived status, relative age. */
+export function dashboardRows(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/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/Component/project-picker/index.d.ts

@@ -0,0 +1,15 @@
+/** A project that claims the repo. */
+export interface PickerCandidate {
+    id: string;
+    name: string;
+}
+/**
+ * The picker screen's rows: a heading naming the repo, then one row per
+ * candidate with `▸` on the selected one.
+ */
+export declare function projectPickerRows(candidates: PickerCandidate[], repo: string, selected: number): string[];
+/**
+ * The non-TTY form (spec Decision 11): the candidate list plus the direct
+ * command, printed once so `gaia ui --here | cat` stays scriptable — no prompt.
+ */
+export declare function projectPickerHint(candidates: PickerCandidate[], repo: string): string;

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

@@ -0,0 +1,42 @@
+// GAIA-223 AC-8 (spec Decision 14) — the picker `gaia ui --here` shows when the
+// cwd's repo is claimed by MORE THAN ONE gaia project.
+//
+// One repo mapping to several projects is designed for, not an edge case:
+// GAIA-126/137 let `.gaia/` hold one conductor config per project, which is how
+// a Drupal multisite repo maps each site to its own GAIA project. Erroring on
+// N>1 would fail permanently, by design, in exactly the repos the feature is
+// most useful in — so the ambiguity is shown rather than resolved behind the
+// user's back.
+//
+// Pure, like every other Component: candidates in, rows out. The kernel owns
+// selection state, Enter and Esc.
+/** Clamp a selection index into the candidate range (0 when there are none). */
+function clamp(selected, length) {
+    if (length <= 0)
+        return 0;
+    return Math.max(0, Math.min(Math.trunc(selected), length - 1));
+}
+/**
+ * The picker screen's rows: a heading naming the repo, then one row per
+ * candidate with `▸` on the selected one.
+ */
+export function projectPickerRows(candidates, repo, selected) {
+    const heading = [`Several gaia projects claim ${repo} — which one?`, ''];
+    if (candidates.length === 0) {
+        return [...heading, 'No projects.'];
+    }
+    const index = clamp(selected, candidates.length);
+    return [
+        ...heading,
+        ...candidates.map((c, i) => `${i === index ? '▸' : ' '} ${c.name}`),
+    ];
+}
+/**
+ * The non-TTY form (spec Decision 11): the candidate list plus the direct
+ * command, printed once so `gaia ui --here | cat` stays scriptable — no prompt.
+ */
+export function projectPickerHint(candidates, repo) {
+    const names = candidates.map((c) => `  ${c.name}`).join('\n');
+    return (`Several gaia projects claim ${repo}:\n${names}\n` +
+        "Open one directly with 'gaia ui project:<name>'.");
+}

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

@@ -0,0 +1,21 @@
+import type { DropshClient } from '../../../types.js';
+import { type ConductorStatus } from '../../conductor/Data/liveness.js';
+/** A derived project row: one distinct project + its liveliest conductor. */
+export interface ProjectRow {
+    project: string;
+    derivedStatus: ConductorStatus;
+    lastSeen: number | null;
+    ageLabel: string;
+}
+/**
+ * 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 screen itself stays a screen/route.
+ */
+export declare function loadProjectRows({ client, nowSeconds, }: {
+    client: DropshClient;
+    nowSeconds: () => number;
+}): Promise<ProjectRow[]>;

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

@@ -0,0 +1,81 @@
+import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
+import { humanizeAge } from '../../../lib/format.js';
+import { deriveConductorStatus, } from '../../conductor/Data/liveness.js';
+/** JSON:API timestamps arrive as ISO-8601 strings; liveness works in seconds. */
+function toEpochSeconds(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'number')
+        return value;
+    if (typeof value !== 'string')
+        return null;
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : Math.floor(ms / 1000);
+}
+/** Id of a single-valued relationship linkage (`data` object), or null. */
+function singleRelId(rel) {
+    const data = rel?.data;
+    if (!data || Array.isArray(data))
+        return null;
+    return data.id ?? null;
+}
+// Most-alive-first ranking so a project with several conductors reports its
+// liveliest one, not whichever the collection happened to return first.
+const STATUS_RANK = {
+    running: 0,
+    stale: 1,
+    offline: 2,
+    'registry-only': 3,
+};
+/**
+ * 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 screen itself stays a screen/route.
+ */
+export async function loadProjectRows({ client, nowSeconds, }) {
+    const params = new DrupalJsonApiParams().addInclude(['project_id']);
+    let doc;
+    try {
+        doc = (await client.get('gaia_conductor/gaia_conductor', params));
+    }
+    catch {
+        return [];
+    }
+    // Resolve each conductor's project name from the sideloaded gaia_project.
+    const projectNameById = new Map();
+    for (const inc of doc.included ?? []) {
+        if (inc.id && typeof inc.attributes?.name === 'string') {
+            projectNameById.set(inc.id, inc.attributes.name);
+        }
+    }
+    const now = nowSeconds();
+    const best = new Map();
+    for (const c of doc.data ?? []) {
+        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 project row.
+        if (!project)
+            continue;
+        const lastSeen = toEpochSeconds(a.last_seen ?? null);
+        const derivedStatus = deriveConductorStatus({
+            present: true,
+            status: typeof a.status === 'string' ? a.status : null,
+            lastSeen,
+            leaseExpiresAt: toEpochSeconds(a.lease_expires_at ?? null),
+        }, now);
+        const prev = best.get(project);
+        if (!prev || STATUS_RANK[derivedStatus] < STATUS_RANK[prev.derivedStatus]) {
+            best.set(project, { derivedStatus, lastSeen });
+        }
+    }
+    return [...best.entries()].map(([project, b]) => ({
+        project,
+        derivedStatus: b.derivedStatus,
+        lastSeen: b.lastSeen,
+        ageLabel: humanizeAge(b.lastSeen, now),
+    }));
+}

package/dist/src/Entity/project/Data/with-tickets.d.ts

@@ -0,0 +1,20 @@
+import type { DropshClient } from '../../../types.js';
+import { type TicketRow } from '../../ticket/Data/tickets.js';
+/** The resolved project header + its ticket rows. */
+export interface ProjectWithTickets {
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    tickets: TicketRow[];
+}
+/**
+ * Resolve a `gaia_project` by its slug (the registry `project`, which matches
+ * the project's `name`) and list its tickets, most-recently-changed first.
+ *
+ * The ticket listing delegates to {@link loadFilteredTickets} with empty
+ * criteria — one include-aware `client.get` path shared with the search/filter
+ * load, so both resolve parent/conductor identically (no dual-mapper drift).
+ */
+export declare function loadProjectWithTickets(client: DropshClient, projectSlug: string): Promise<ProjectWithTickets>;

package/dist/src/Entity/project/Data/with-tickets.js

@@ -0,0 +1,36 @@
+// Resolving ONE project by slug together with its ticket rows. The project half of
+// the former `Service/project-data.ts` (GAIA-236 phase 3).
+//
+// This is one of exactly two enumerated `project/Data -> ticket/Data` edges the
+// boundary guard allows: the ticket listing deliberately delegates to
+// `loadFilteredTickets` so the search/filter path and this one resolve
+// parent/conductor through the same mapper, with no dual-mapper drift.
+import { loadFilteredTickets, } from '../../ticket/Data/tickets.js';
+/**
+ * Resolve a `gaia_project` by its slug (the registry `project`, which matches
+ * the project's `name`) and list its tickets, most-recently-changed first.
+ *
+ * The ticket listing delegates to {@link loadFilteredTickets} with empty
+ * criteria — one include-aware `client.get` path shared with the search/filter
+ * load, so both resolve parent/conductor identically (no dual-mapper drift).
+ */
+export async function loadProjectWithTickets(client, projectSlug) {
+    const projectRes = await client
+        .collection('gaia_project')
+        .where('name', '=', projectSlug)
+        .first();
+    const projectId = projectRes?.id ?? projectSlug;
+    const tickets = await loadFilteredTickets(client, projectId, {
+        query: '',
+        state: null,
+        type: null,
+    });
+    return {
+        project: {
+            id: projectId,
+            name: projectRes?.attr('name') ?? projectSlug,
+            slug: projectSlug,
+        },
+        tickets,
+    };
+}

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>;
+};