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

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

@@ -1,4 +1,7 @@
-import { cellsRow, textNode } from '../../lib/vnode.js';
+import { cellsRow, textNode, } from '../../lib/vnode.js';
+import { plainLine } from '../markdown/index.js';
+/** Whether a line is columns rather than prose — `cells` is the discriminant. */
+const isCells = (line) => typeof line !== 'string' && 'cells' in line;
 /**
  * A line as the text a surface with no layout prints.
  *
@@ -6,29 +9,58 @@ import { cellsRow, textNode } from '../../lib/vnode.js';
  * puts between two cells: the pipe and the tree then say the same thing about
  * what separates two columns, and only the alignment inside a column is the
  * renderer's own.
+ *
+ * GAIA-372 D4 — for a {@link StyledLine} this returns the RENDERED text, which is the
+ * whole of how parity is achieved: `SectionRow.text` carries it and the pipe
+ * prints exactly that, so `gaia ui <id> | cat` and the interactive tree are the
+ * same rendering by construction. The tree merely adds the attributes a pipe
+ * cannot carry. There is no raw-only pipe path left to disagree (AC-3).
  */
-export const lineText = (line) => typeof line === 'string'
-    ? line
-    : line.cells
-        .map((cell) => cell.text)
-        .join(' ')
-        .replace(/\s+$/, '');
+export const lineText = (line) => {
+    if (typeof line === 'string')
+        return line;
+    if (isCells(line)) {
+        return line.cells
+            .map((cell) => cell.text)
+            .join(' ')
+            .replace(/\s+$/, '');
+    }
+    return line.text;
+};
 /**
- * The MINIMAL MARKDOWN rule: an ATX heading (`#`…`######`) renders as bold with
- * the markers stripped — the same rule a section heading follows. Bullets and
- * code fences stay raw by design (explicit v1 decision).
+ * Any body line as a RENDERED line — GAIA-372 D3/D8.
  *
- * ONE function, because every renderer of a body line goes through it:
- * {@link sectionRows} for a flat section, {@link expandableRows} for a
- * collapsible one, and `Entity/run/Component/run-detail` for a log entry. The
- * Description block is rendered by two of them at once — flat on the piped
- * render, expandable on the Overview tab — and a rule living in only one would
- * make the same body look different depending on which renderer reached it.
+ * A plain or columned row is LIFTED (one unparsed span) rather than refused,
+ * because a consumer that needs rendered lines — the collapsible Description
+ * entry, whose extract reads `line.heading` — is handed a `Description` section
+ * whose empty state is the plain string `No description.` Lifting never parses,
+ * so nothing here can re-introduce a Markdown rule on the plain path.
  */
-export function markdownRow(line) {
-    const md = /^(#{1,6})\s+(.*)$/.exec(line);
-    return md ? { text: md[2] ?? '', bold: true } : { text: line, bold: false };
-}
+export const styledOf = (line) => typeof line === 'string' || isCells(line) ? plainLine(lineText(line)) : line;
+/**
+ * One body line as the row it is — the ONE place D3's three variants are read
+ * apart, so a flat section and a collapsible entry cannot answer differently for
+ * the same line.
+ */
+const bodyRow = (key, line) => {
+    // Columns are never read as Markdown: a run number opens with `#`, and the ATX
+    // rule would both bold the row and eat the number.
+    if (isCells(line)) {
+        return { key, text: lineText(line), bold: false, cells: line.cells };
+    }
+    // A plain string is PLAIN. Nothing parses it (D3) — which is what puts
+    // `Assignment`, `Branch`, `Links` and `Labels` structurally out of reach.
+    if (typeof line === 'string')
+        return { key, text: line, bold: false };
+    return {
+        key,
+        text: line.text,
+        // An ATX heading inside a body is the ROW's weight, exactly as it was; what
+        // decides it is now the rendered line's own flag rather than a re-match.
+        bold: line.heading,
+        runs: line.runs,
+    };
+};
 /**
  * A heading as an id fragment: `PER USER` → `per-user`.
  *
@@ -41,6 +73,57 @@ export const sectionKey = (heading) => heading
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-|-$/g, '');
+/**
+ * The same, for a heading that is DATA rather than one of the built-in set —
+ * GAIA-373 AC-10.
+ *
+ * {@link sectionKey} is LOSSY: it lowercases and collapses every run of
+ * non-alphanumeric characters onto one `-`. That is injective over the closed
+ * built-in headings (`Per user`, `Latest summary`), and it stops being injective
+ * the moment a contributed panel heads its sections with whatever it is
+ * listing. The shipped artifacts viewer heads them with paths under the ticket's
+ * tree, so `/`, `.` and `-` all land on the same character and two ordinary
+ * captures collapse onto one key:
+ *
+ *     playwright/logs/walk.txt  ->  playwright-logs-walk-txt
+ *     playwright/logs-walk.txt  ->  playwright-logs-walk-txt
+ *
+ * A key is an IDENTITY — `Kernel/mount.ts` refuses a repeated id, and it refuses
+ * it while MOUNTING, past the host's guard around `panel.sections()` and on a
+ * draw path with no `catch` — so a lossy key is not a cosmetic collision, it is
+ * the cockpit going down on a message naming neither the addon nor the file.
+ *
+ * SO THE SEPARATORS ARE ENCODED RATHER THAN COLLAPSED. Every UTF-8 byte outside
+ * `[a-z0-9]` becomes `_<hex>`, two digits, lower case. The escape has a fixed
+ * length and `_` is itself escaped (`_5f`), so the mapping is reversible and
+ * therefore injective — including over case (`README.txt` and `readme.txt` are
+ * two files on this filesystem) and over a heading that already looks like an
+ * escape.
+ *
+ * WHY THE OUTPUT CARRIES NO `-`, which is a second property and not a side
+ * effect. A key never becomes an id on its own: it is always suffixed
+ * (`-heading`, `-gap`, `-empty`, `-header`, `-<index>`). Injectivity of the key
+ * alone would not settle the id, because the suffix boundary would be
+ * ambiguous — with `-` allowed inside a key, section `a` at body index 12 and
+ * section `a-1` at body index 2 would both be `a-12`. With no `-` inside a key
+ * the first `-` after the screen's own prefix always ends the key, so a key and
+ * its suffix are both recovered from an id and two ids can only be equal when
+ * both halves are. Within one section the suffixes are distinct by construction:
+ * the indices are digits and the four literals are not.
+ *
+ * NOT THE BUILT-IN PATH. `sectionRows` and the ticket detail's tabs keep
+ * {@link sectionKey} as their default, so no built-in node id moves (AC-2) — a
+ * `_` in a key is exactly the mark of a heading that came from a contribution.
+ *
+ * WHAT THIS STILL DOES NOT FIX, said plainly: two panel sections carrying the
+ * SAME heading. No injective map over headings can separate two identical
+ * headings, so that case remains the loud refusal it is today. It is out of
+ * scope for GAIA-373 and belongs to whatever gives a panel section an identity
+ * distinct from its title.
+ */
+export const panelSectionKey = (heading) => Array.from(new TextEncoder().encode(heading), (byte) => (byte >= 0x30 && byte <= 0x39) || (byte >= 0x61 && byte <= 0x7a)
+    ? String.fromCharCode(byte)
+    : `_${byte.toString(16).padStart(2, '0')}`).join('');
 /**
  * Flatten `{heading, lines}` sections into KEYED rows: the heading, its body,
  * and the blank line that closes the section.
@@ -51,21 +134,18 @@ export const sectionKey = (heading) => heading
  * property that lets the Dashboard hand over renderables while its pipe keeps
  * emitting the bytes it always did (spec F5).
  */
-export function sectionRows(sections) {
+export function sectionRows(sections, 
+// GAIA-373 — HOW a heading becomes a key, as an argument. The built-in
+// derivation stays the default so every existing caller keys exactly as it
+// did (AC-2); a caller whose headings are data passes
+// {@link panelSectionKey}, which is injective over them.
+keyOf = sectionKey) {
     const out = [];
     for (const section of sections) {
-        const id = sectionKey(section.heading);
+        const id = keyOf(section.heading);
         out.push({ key: `${id}-heading`, text: section.heading, bold: true });
         section.lines.forEach((line, index) => {
-            const key = `${id}-${index}`;
-            // Columns are never read as markdown: a run number opens with `#`, and the
-            // ATX rule would both bold the row and eat the number.
-            if (typeof line !== 'string') {
-                out.push({ key, text: lineText(line), bold: false, cells: line.cells });
-                return;
-            }
-            const { text, bold } = markdownRow(line);
-            out.push({ key, text, bold });
+            out.push(bodyRow(`${id}-${index}`, line));
         });
         out.push({ key: `${id}-gap`, text: '', bold: false });
     }
@@ -85,10 +165,17 @@ export const sectionRowNode = (prefix, row, selected = false) => row.cells === u
         content: row.text,
         bold: row.bold,
         selected,
+        // GAIA-372 D5 — spread rather than passed as `undefined`, for
+        // `exactOptionalPropertyTypes`: a row with no runs declares none, and
+        // `linked()` then returns the plain string it always did.
+        ...(row.runs === undefined ? {} : { runs: row.runs }),
     })
     : cellsRow(`${prefix}-${row.key}`, row.cells, selected);
 // The same rows as plain text plus the INDICES that are bold (section headings +
-// markdown ATX headings) — the shape the row surface needs. Headings carry NO
+// a rendered body's own ATX headings) — the shape the row surface needs. The
+// RUNS are dropped on this path by definition: a pipe carries no styling, and
+// `row.text` is already the rendered text, so what it prints is what the tree
+// draws minus the attributes (GAIA-372 D4). Headings carry NO
 // ANSI here: the draw step applies bold after fit(), so sanitizeDisplay never
 // sees (and never strips) the ESC.
 export function flattenSections(sections) {
@@ -138,8 +225,7 @@ export function expandableRows(entries, { expanded = new Set(), emptyMessage, em
         });
         const body = expanded.has(i) ? entry.expanded : entry.collapsed;
         body.forEach((line, index) => {
-            const { text, bold } = markdownRow(line);
-            rows.push({ key: `${entry.key}-${index}`, text, bold });
+            rows.push(bodyRow(`${entry.key}-${index}`, line));
         });
     });
     return { rows, headerRows, selectable: entries.length };

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

@@ -13,6 +13,9 @@ export declare const ROOT_TABS: readonly [{
 }, {
     readonly id: "conductors";
     readonly label: "Conductors";
+}, {
+    readonly id: "users";
+    readonly label: "Users";
 }];
 /** The project level: the tabs of an opened project. */
 export declare const PROJECT_TABS: readonly [{
@@ -62,6 +65,22 @@ export declare const TICKET_TABS: readonly [{
     readonly id: "runs";
     readonly label: "Runs";
 }];
+/**
+ * The user level: Overview · Tickets · Runs for one person (GAIA-377 D1).
+ *
+ * Destinations, not modes — each tab is its own screen in the slice that owns
+ * its query (D2), so Tab runs a real `Router.navigate` and preserves `userId`.
+ */
+export declare const USER_TABS: readonly [{
+    readonly id: "overview";
+    readonly label: "Overview";
+}, {
+    readonly id: "tickets";
+    readonly label: "Tickets";
+}, {
+    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 [{
@@ -73,6 +92,9 @@ export declare const TAB_LEVELS: {
     }, {
         readonly id: "conductors";
         readonly label: "Conductors";
+    }, {
+        readonly id: "users";
+        readonly label: "Users";
     }];
     readonly project: readonly [{
         readonly id: "dashboard";
@@ -100,6 +122,16 @@ export declare const TAB_LEVELS: {
         readonly id: "runs";
         readonly label: "Runs";
     }];
+    readonly user: readonly [{
+        readonly id: "overview";
+        readonly label: "Overview";
+    }, {
+        readonly id: "tickets";
+        readonly label: "Tickets";
+    }, {
+        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;
@@ -117,13 +149,34 @@ export type TopTabId = {
  * 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.
+ *
+ * GAIA-373 D5/D6 — the `ticket` arm is the one that is NOT a literal union, and
+ * it is also the one that carries an optional bar of its own. Both halves have
+ * the same cause: the ticket level is not a DESTINATION level.
+ * `router.navigateTab` is never reached for it, because `selectTopTab` claims
+ * every ticket tab (GAIA-346 D4), so the literal union that protects root/project
+ * NAVIGATION has no target here — while a contributed section mode
+ * (`gaia/artifacts`) is data from the contribution store and cannot be a literal
+ * in this file at all. Root and project keep theirs intact, so
+ * `topTabBar('root', 'runs')` is still a TS2345.
+ *
+ * `tabs` is read by BOTH bar builders below and by the kernel's Tab cycle, so
+ * the bar drawn, the bar clicked and the bar cycled are three readings of one
+ * field rather than three answers.
  */
 export type TabLocation = {
-    [L in TabLevel]: {
-        level: L;
-        tab: TabIdOf<L>;
-    };
-}[TabLevel];
+    level: 'root';
+    tab: TabIdOf<'root'>;
+} | {
+    level: 'project';
+    tab: TabIdOf<'project'>;
+} | {
+    level: 'ticket';
+    tab: string;
+    tabs?: readonly TopTab[];
+};
+/** The entries a location draws: its own, else its level's registry. */
+export declare const tabsOfLocation: (location: TabLocation) => readonly TopTab[];
 /**
  * The bar as the PIECES it is drawn from: one part per tab, carrying that tab's
  * id, with the joins between them carrying none.
@@ -191,5 +244,11 @@ export declare function topTabParts<L extends TabLevel>(level: L, activeId: TabI
  * 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`.
+ *
+ * GAIA-373 — `TabBarPart<string>` rather than the `TopTabId` default, and that
+ * is an honest widening rather than a lost check: a location may carry a bar of
+ * its own now, whose entries are CONTRIBUTED (`gaia/artifacts`) and by
+ * construction outside every union derived from `TAB_LEVELS`. The level-typed
+ * {@link topTabParts} keeps the narrow ids for callers that name a level.
  */
-export declare function tabPartsFor(location: TabLocation): TabBarPart[];
+export declare function tabPartsFor(location: TabLocation): TabBarPart<string>[];

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

@@ -29,10 +29,9 @@
 // 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`)
-// 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.
+// Only tabs that are actually navigable are listed. GAIA-377 added `Users` with
+// its screens; a tab drawn before its screen exists would advertise navigation
+// the operator cannot take, which is the very defect GAIA-239 removes.
 //
 // GAIA-232 added `conductors`, and put it on the ROOT level although the note
 // above once reserved it for the project level. A conductor is an operator
@@ -53,6 +52,8 @@ export const ROOT_TABS = [
     { id: 'dashboard', label: 'Dashboard' },
     { id: 'projects', label: 'Projects' },
     { id: 'conductors', label: 'Conductors' },
+    // GAIA-377 D1 — arrives with its screens; see USER_TABS.
+    { id: 'users', label: 'Users' },
 ];
 /** The project level: the tabs of an opened project. */
 export const PROJECT_TABS = [
@@ -88,12 +89,28 @@ export const TICKET_TABS = [
     { id: 'related', label: 'Related' },
     { id: 'runs', label: 'Runs' },
 ];
+/**
+ * The user level: Overview · Tickets · Runs for one person (GAIA-377 D1).
+ *
+ * Destinations, not modes — each tab is its own screen in the slice that owns
+ * its query (D2), so Tab runs a real `Router.navigate` and preserves `userId`.
+ */
+export const USER_TABS = [
+    { id: 'overview', label: 'Overview' },
+    { id: 'tickets', label: 'Tickets' },
+    { id: 'runs', label: 'Runs' },
+];
 /** The tab bars, keyed by level — the one place a level is named. */
 export const TAB_LEVELS = {
     root: ROOT_TABS,
     project: PROJECT_TABS,
     ticket: TICKET_TABS,
+    user: USER_TABS,
 };
+/** The entries a location draws: its own, else its level's registry. */
+export const tabsOfLocation = (location) => 'tabs' in location && location.tabs
+    ? location.tabs
+    : TAB_LEVELS[location.level];
 /** 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. */
@@ -133,7 +150,7 @@ export function topTabBar(level, activeId) {
  * not ask the compiler to correlate two independently narrowed properties.
  */
 export function tabBarFor(location) {
-    return renderBar(TAB_LEVELS[location.level], location.tab);
+    return renderBar(tabsOfLocation(location), location.tab);
 }
 // GAIA-256 spec D2 — `locateTab` USED TO LIVE HERE and is deliberately gone.
 //
@@ -168,7 +185,13 @@ export function topTabParts(level, activeId) {
  * 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`.
+ *
+ * GAIA-373 — `TabBarPart<string>` rather than the `TopTabId` default, and that
+ * is an honest widening rather than a lost check: a location may carry a bar of
+ * its own now, whose entries are CONTRIBUTED (`gaia/artifacts`) and by
+ * construction outside every union derived from `TAB_LEVELS`. The level-typed
+ * {@link topTabParts} keeps the narrow ids for callers that name a level.
  */
 export function tabPartsFor(location) {
-    return renderParts(TAB_LEVELS[location.level], location.tab);
+    return renderParts(tabsOfLocation(location), location.tab);
 }

package/dist/src/Entity/collection.js

@@ -50,7 +50,7 @@ function readTotal(doc) {
  * back is `pad`'s reason for existing: `cellFill` fills to a width the COLUMN
  * DECLARES, never to one measured off the page.
  * Reaching `lib/width.ts` for the measurement is a DELIBERATE decision on top of
- * A2 already being reported as missed (`docs/evidence/GAIA-340/teardown-a2.txt`)
+ * A2 already being reported as missed (`docs/evidence/GAIA-340/teardown-a2.txt`, in git history since GAIA-371)
  * — the module survives this ticket, so the alternative is not "no measurement"
  * but "an illegible cut", and R5's rule against re-implementing it under another
  * name is honoured by calling it rather than copying it.

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

@@ -1,5 +1,21 @@
-import { BaseScreen, type ScreenContext } from '../../../Screen/screen.js';
-export declare class ConductorsScreen extends BaseScreen {
+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 ConductorRow } from '../Data/conductors.js';
+/** Loaded conductors page — rows plus project-name lookup for the table. */
+interface ConductorsData {
+    readonly rows: readonly ConductorRow[];
+    readonly projectNames: ReadonlyMap<string, string>;
+}
+/**
+ * Conductors list — a normal {@link AsyncScreen}.
+ *
+ * Refresh is the shared mechanism (GAIA-376 `ui-refresh` file + `R`), not a
+ * screen-private timer. Enter loads; navigation away cancels in-flight reads
+ * via the async lifecycle.
+ */
+export declare class ConductorsScreen extends AsyncScreen<ConductorsData> {
     static readonly route: {
         id: string;
         path: string;
@@ -12,56 +28,25 @@ export declare class ConductorsScreen extends BaseScreen {
     };
     readonly id: string;
     readonly frameId = "conductors";
-    private rows;
-    private projectNames;
     private selectedIndex;
     private logFor;
-    private status;
-    private reading;
-    private timer;
     private readonly busyIds;
-    private activation;
     topTab(): {
         readonly level: "root";
         readonly tab: "conductors";
     };
-    private quietRead;
-    get busy(): boolean;
     reload(context: ScreenContext): void;
-    enter(context: ScreenContext): void;
-    leave(): void;
-    /**
-     * GAIA-340 D1 — the list as the renderable tree the screen hands over, and
-     * since GAIA-345 that tree is the SHARED table's (AC 1/2).
-     *
-     * There is no `conductor-list` component any more: the eight columns, the
-     * noun and the empty message are `CONDUCTOR_TABLE`, declared beside the row
-     * mapper that produces the rows. What this screen still owns is the CONTEXT
-     * the columns read — the frame's clock, which conductors have an action in
-     * flight, and the project names its own small read resolved — because none of
-     * those is a property of a `gaia_conductor` record.
-     *
-     * THE OPEN LOG IS NOT A ROW OF THE LIST, so it is not in the table: it is
-     * neither keyed on a conductor nor laid out in the columns, and a log line
-     * keyed under the list's ids could collide with a row's. It stays its own
-     * block below the table, whose lines are keyed by position — honest for a
-     * block replaced wholesale on every read that indexes nothing outside itself.
-     * The wrapper is stated on EVERY frame, log or no log, so the body's root
-     * node keeps one identity across the keypress that opens one.
-     *
-     * MOUNTED WHOLE, so the bound on its nodes is the data's own: one box of 8
-     * cells per conductor, over the conductors of one user on one control plane,
-     * plus at most 40 log lines. `@opentui/core@0.5.1` hands out 16 382 before it
-     * throws, so this screen windows nothing of its own — deliberately, not by
-     * omission.
-     */
-    private surface;
-    present(context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    get rows(): readonly ConductorRow[];
+    protected load(context: ScreenContext): Promise<ConductorsData>;
+    protected renderLoading(): string[];
+    protected renderReady(data: ConductorsData, context: ScreenContext): VNode;
+    protected didLoad(data: ConductorsData): void;
+    protected chrome(_context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
     select(index: number, context: ScreenContext): boolean;
     activate(index: number, context: ScreenContext): boolean;
     handleInput(input: string, context: ScreenContext): boolean;
     reset(): void;
-    private refresh;
     private act;
-    private stopTimer;
 }
+export {};