@gaia-ai/addon-gaia-ui 0.13.0 → 0.13.1

package/dist/src/Entity/statistics/Data/statistics.d.ts

@@ -39,18 +39,31 @@ export interface SeriesFigureValue {
     days: StatisticDay[];
 }
 /**
- * A `ratio` figure's value: its two named factors, side by side.
+ * A `ratio` figure's value: the quotient, and the two factors behind it.
  *
- * The ratio itself is computed CLIENT-SIDE from the two totals — a
- * server-computed copy would be a second source of truth that can disagree
- * (unchanged from GAIA-377's `closedPerRun`, now over server-named factors
- * instead of the fixed tickets/runs pair).
+ * The division was CLIENT-SIDE until GAIA-481 D3, on the reasoning that a
+ * server-computed copy would be a second source of truth. The web Stats tabs
+ * reversed that reasoning: a second SURFACE would have had to re-implement
+ * the same rule in PHP, so the division and its zero-denominator case moved
+ * to the server instead. `ratio` is therefore READ and rendered, never
+ * recomputed here — and it arrives already formatted, because the empty
+ * value is part of the rule rather than a presentation choice each surface
+ * makes for itself.
+ *
+ * `numerator` and `denominator` still travel beside it, unchanged.
  */
 export interface RatioFigureValue {
     generated: string;
+    ratio: RatioQuotients;
     numerator: WindowsFigureValue;
     denominator: WindowsFigureValue;
 }
+/** A ratio's derived value per trailing window: two decimals, or `—`. */
+export interface RatioQuotients {
+    day: string;
+    week: string;
+    month: string;
+}
 export type FigureValue = WindowsFigureValue | SeriesFigureValue | RatioFigureValue;
 /** One figure discovery names: which blocks the caller may render (spec D5). */
 export interface StatisticListing {
@@ -132,11 +145,3 @@ export declare function loadStatisticValue(client: DropshClient, statisticId: st
  * its own (spec D5). Figures already arrive weight-ordered from discovery.
  */
 export declare function loadGroupStatistics(client: DropshClient, scopeId: string): Promise<GroupStatisticsResult>;
-/** Closed-per-run-shaped ratio, for each trailing window, from two totals. */
-export declare function ratioOf(numerator: StatisticsWindows, denominator: StatisticsWindows): {
-    day: number | null;
-    week: number | null;
-    month: number | null;
-};
-/** Format a ratio value for the screen: two decimals, or `—`. */
-export declare const formatRatio: (value: number | null) => string;

package/dist/src/Entity/statistics/Data/statistics.js

@@ -1,4 +1,12 @@
 import { DrupalJsonApiParams } from 'drupal-jsonapi-params';
+/**
+ * What a ratio window reads as when there is nothing to divide by.
+ *
+ * The server owns this rule and sends the character; this constant exists
+ * only so a response that carries no quotient at all degrades to the same
+ * thing rather than to an empty cell.
+ */
+const RATIO_EMPTY = '—';
 /** How an `id: null` breakdown row is named on screen. */
 export const UNATTRIBUTED_LABEL = '— unattributed';
 const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : 0;
@@ -43,6 +51,23 @@ function windowsFigureOf(attributes) {
         ...(rows ? { rows } : {}),
     };
 }
+/**
+ * A ratio figure's quotients, as the server formatted them (GAIA-481 D3).
+ *
+ * A control plane that predates the move sends no `ratio` at all, and this
+ * reads the empty value for every window rather than throwing or dividing a
+ * replacement: an older server is a missing figure, not a wrong one, and the
+ * one thing this must not do is quietly reintroduce the division it replaced.
+ */
+function quotientsOf(value) {
+    const source = (value ?? {});
+    const windowOf = (key) => typeof source[key] === 'string' ? source[key] : RATIO_EMPTY;
+    return {
+        day: windowOf('day'),
+        week: windowOf('week'),
+        month: windowOf('month'),
+    };
+}
 function figureValueOf(attributes) {
     if (Array.isArray(attributes.days)) {
         return {
@@ -56,6 +81,7 @@ function figureValueOf(attributes) {
         attributes.denominator !== null) {
         return {
             generated: typeof attributes.generated === 'string' ? attributes.generated : '',
+            ratio: quotientsOf(attributes.ratio),
             numerator: windowsFigureOf(attributes.numerator),
             denominator: windowsFigureOf(attributes.denominator),
         };
@@ -198,14 +224,12 @@ export async function loadGroupStatistics(client, scopeId) {
     }
     return { kind: 'ok', figures };
 }
-/** Closed-per-run-shaped ratio, for each trailing window, from two totals. */
-export function ratioOf(numerator, denominator) {
-    const ratio = (n, d) => (d > 0 ? n / d : null);
-    return {
-        day: ratio(numerator.day, denominator.day),
-        week: ratio(numerator.week, denominator.week),
-        month: ratio(numerator.month, denominator.month),
-    };
-}
-/** Format a ratio value for the screen: two decimals, or `—`. */
-export const formatRatio = (value) => value === null ? '—' : value.toFixed(2);
+// GAIA-481 D3 — `ratioOf` and `formatRatio` were exported from here, and are
+// gone. A `ratio` figure's quotient is the server's now
+// (`RatioFigureValue.ratio`), so this module deliberately offers no ratio
+// arithmetic for a caller to reach for: a shared helper sitting beside the
+// server's own value is exactly how the second implementation would come
+// back. The team Users screen still divides, because it derives a PER-MEMBER
+// quotient out of two breakdown figures' rows and no configured figure
+// produces that one; it owns that arithmetic privately rather than sharing
+// it from here.

package/dist/src/Entity/statistics/render.js

@@ -1,5 +1,4 @@
 import { statsPanelRows, } from '../../Component/stats-panel/index.js';
-import { formatRatio, ratioOf } from './Data/statistics.js';
 // GAIA-456 spec D2/D7 — mapping the four configured display kinds onto the
 // renderers the TUI already had: `windows` is the totals row GAIA-256 drew,
 // `breakdown` is the label-by-window table, `series` is the seven-day strip
@@ -24,13 +23,19 @@ function seriesLines(days) {
     const counts = `  ${'Count'.padEnd(LABEL - 2, ' ')}${days.map((row) => cell(String(row.count))).join('')}`;
     return [weekdays, dates, counts];
 }
-/** A ratio figure's two factor totals, divided per trailing window. */
-function ratioLines(numerator, denominator) {
-    const ratios = ratioOf(numerator, denominator);
+/**
+ * A ratio figure's quotient per trailing window, as the SERVER divided it.
+ *
+ * The values arrive already formatted (GAIA-481 D3), so this lays them out
+ * and does nothing else — no division and no em-dash rule, both of which are
+ * the server's now and would otherwise be a terminal-only second opinion on
+ * the same figure the browser renders.
+ */
+function ratioLines(ratios) {
     return [
-        `  ${WINDOWS[0]}                     ${formatRatio(ratios.day)}`,
-        `  ${WINDOWS[1]}                       ${formatRatio(ratios.week)}`,
-        `  ${WINDOWS[2]}                      ${formatRatio(ratios.month)}`,
+        `  ${WINDOWS[0]}                     ${ratios.day}`,
+        `  ${WINDOWS[1]}                       ${ratios.week}`,
+        `  ${WINDOWS[2]}                      ${ratios.month}`,
     ];
 }
 /** One figure's own section: its label as the heading, its display kind's lines. */
@@ -41,10 +46,7 @@ export function figureSection({ listing, value }) {
             return { heading, lines: seriesLines(value.days) };
         case 'ratio': {
             const ratio = value;
-            return {
-                heading,
-                lines: ratioLines(ratio.numerator.total, ratio.denominator.total),
-            };
+            return { heading, lines: ratioLines(ratio.ratio) };
         }
         case 'breakdown': {
             const windows = value;

package/dist/src/Entity/team/Screen/team-users.js

@@ -4,7 +4,7 @@ import { ListCursor } from '../../../lib/cursor.js';
 import { columnNode } from '../../../lib/vnode.js';
 import { AsyncScreen } from '../../../Screen/async-screen.js';
 import { listRowIds, listTableTree } from '../../collection.js';
-import { formatRatio, loadGroupStatistics, ratioOf, } from '../../statistics/Data/statistics.js';
+import { loadGroupStatistics, } from '../../statistics/Data/statistics.js';
 import { listUsers, TEAM_MEMBER_TABLE, } from '../../user/Data/users.js';
 import { listTeamMemberIds } from '../Data/members.js';
 import { TeamsScreen } from './teams-screen.js';
@@ -48,6 +48,20 @@ function rowsById(statistics, statisticId) {
     }
     return map;
 }
+/**
+ * This screen's own closed-per-run, for ONE member over the 30-day window.
+ *
+ * Deliberately local and unexported (GAIA-481 D3). A `ratio` FIGURE is
+ * divided by the server, and this is not one: it is derived per member from
+ * two breakdown figures' rows, and no configured figure produces it. Keeping
+ * it here rather than in the shared statistics module is what stops it being
+ * mistaken for the general "how a ratio is computed" helper and reached for
+ * by a surface that should be reading the server's value instead.
+ *
+ * The rule matches the server's so the two columns agree on screen: two
+ * decimals, and an em-dash when there is nothing to divide by.
+ */
+const perMemberRatio = (numerator, denominator) => denominator > 0 ? (numerator / denominator).toFixed(2) : '—';
 /** One member's row: identity from the collection, figures from the two per-user breakdowns. */
 function rowOf(user, ticketsById, runsById) {
     const tickets30d = ticketsById.get(user.id)?.month ?? 0;
@@ -57,7 +71,7 @@ function rowOf(user, ticketsById, runsById) {
         label: user.label,
         tickets30d,
         runs30d,
-        closedPerRun30d: formatRatio(ratioOf({ day: 0, week: 0, month: tickets30d }, { day: 0, week: 0, month: runs30d }).month),
+        closedPerRun30d: perMemberRatio(tickets30d, runs30d),
     };
 }
 /**

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

@@ -251,6 +251,15 @@ export declare class TicketDetailScreen extends AsyncScreen<TicketDetailDocument
      * operator saw; a table whose `rows()` throws resolves to the error branch and
      * simply has no row to activate.
      */
+    /**
+     * GAIA-500 — `l`/`t`'s shared plumbing: resolve the active table's selected
+     * row and ask its `copyLocal`/`copyTunnel`, returning `undefined` when there
+     * is no active table, the table does not implement that side, or the row has
+     * nothing to offer — in every one of which cases the key is left UNHANDLED
+     * (the caller falls through) rather than reporting a copy that did not
+     * happen, exactly as `l`/`t` do nothing on every tab that is not a table.
+     */
+    private copyActiveTableRow;
     private activateTableRow;
     /** Tests and the busy indicator: the row ids whose activation is in flight. */
     activatingRowIds(): string[];

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

@@ -428,24 +428,49 @@ export class TicketDetailScreen extends AsyncScreen {
         // `selectTopTab` seam would be dead code on the key path. The wrap comes from
         // `TAB_LEVELS.ticket` now, the same wrap every other level gets.
         //
-        // GAIA-326 — the same copy ladder as the ticket LIST (`y` the identifier,
-        // `Y` the link), acting on the ticket that is open. This screen has no text
-        // field, so the keys need no guard beyond the `ready`/`full` gate above.
-        if (input === 'y' || input === 'Y') {
-            this.status = this.copyOpenTicket(input === 'Y', context);
-            context.requestDraw();
-            return true;
-        }
         const view = this.currentView(context);
         // GAIA-475 UX — `s` STARTS and `x` STOPS the selected row's action on a
         // TABLE tab, two distinct keys because Enter reads as "expand" on a detail
         // screen and one key doing both is a confusing toggle. Only when a table is
         // the active contribution, so `s`/`x` are untouched everywhere else.
         const onTable = this.activeContribution(context)?.type === 'table';
+        // GAIA-326 — the same copy ladder as the ticket LIST (`y` the identifier,
+        // `Y` the link), acting on the ticket that is open. NOT on a table tab
+        // (GAIA-500): a table's own rows have their own copy (`l`/`t`), a
+        // different target entirely, and `y`/`Y` copying the open ticket instead —
+        // a fact about the SCREEN, unrelated to whatever row is selected — read as
+        // two unrelated "copy" meanings live at once, confusing enough to report.
+        // This screen has no text field, so the keys need no guard beyond the
+        // `ready`/`full` gate above.
+        if (!onTable && (input === 'y' || input === 'Y')) {
+            this.status = this.copyOpenTicket(input === 'Y', context);
+            context.requestDraw();
+            return true;
+        }
         if (onTable && input === 's' && view.selectable > 0)
             return this.activate(this.selectedEntry, context, 'activate');
         if (onTable && input === 'x' && view.selectable > 0)
             return this.activate(this.selectedEntry, context, 'deactivate');
+        // GAIA-500 — `l` copies the selected row's LOCAL address, `t` the address
+        // reached through the TUNNEL: the same two-distinct-keys shape as `s`/`x`,
+        // for the same reason — one key meaning "copy whichever of two addresses
+        // happens to apply" is the confusing toggle this avoids.
+        if (onTable && input === 'l' && view.selectable > 0) {
+            const copied = this.copyActiveTableRow(context, 'local');
+            if (copied !== undefined) {
+                this.status = copied;
+                context.requestDraw();
+                return true;
+            }
+        }
+        if (onTable && input === 't' && view.selectable > 0) {
+            const copied = this.copyActiveTableRow(context, 'tunnel');
+            if (copied !== undefined) {
+                this.status = copied;
+                context.requestDraw();
+                return true;
+            }
+        }
         if ((input === 'enter' || input === ' ') && view.selectable > 0)
             return this.activate(this.selectedEntry, context);
         // GAIA-369 AC-7 — "HANDLED" MEANS THE SELECTION MOVED, and that is the whole
@@ -614,20 +639,38 @@ export class TicketDetailScreen extends AsyncScreen {
         const view = this.currentView(context);
         const arrows = view.selectable > 1 ? 'select' : 'scroll';
         // GAIA-346 — `Tab section`; kernel owns Esc/q. GAIA-373 — section via registry.
+        const contribution = this.activeContribution(context);
+        const onTable = contribution?.type === 'table';
         const actions = [
             actionItem('detail-tab', 'Tab', 'section'),
             actionItem('detail-edit', 'e', 'edit'),
-            actionItem('detail-copy', 'y', 'copy'),
-            actionItem('detail-link', 'Y', 'link'),
-            actionItem('detail-arrows', '↑↓', arrows),
         ];
+        // GAIA-500 — NOT on a table tab: a table's own rows carry their own copy
+        // (`l`/`t` below), a different target than the open ticket, and having
+        // both live on the same screen at once is what read as confusing enough
+        // to report — named `copy id`/`copy link` here rather than the bare
+        // `copy`/`link` this carried before, so it cannot misread as this row's
+        // copy on the one tab where it is not.
+        if (!onTable) {
+            actions.push(actionItem('detail-copy', 'y', 'copy id'));
+            actions.push(actionItem('detail-link', 'Y', 'copy link'));
+        }
+        actions.push(actionItem('detail-arrows', '↑↓', arrows));
         if (view.selectable > 0) {
             // GAIA-475 — a table tab offers its action under a dedicated key `s`, so
             // the footer names it rather than leaving the operator to guess Enter does
             // something other than expand.
-            if (this.activeContribution(context)?.type === 'table') {
+            if (onTable && contribution) {
                 actions.push(actionItem('detail-share', 's', 'start'));
                 actions.push(actionItem('detail-unshare', 'x', 'stop'));
+                // GAIA-500 — the row's own copy, distinct from `y`/`Y` above (which a
+                // table tab no longer even offers) for the reason `s`/`x` already read
+                // "start"/"stop" rather than "share" twice — which of two things a key
+                // copies is the part worth saying.
+                if (contribution.copyLocal)
+                    actions.push(actionItem('detail-copy-local', 'l', 'copy local'));
+                if (contribution.copyTunnel)
+                    actions.push(actionItem('detail-copy-tunnel', 't', 'copy tunnel'));
             }
             else {
                 actions.push(this.activeSectionId(context) === 'runs' &&
@@ -740,6 +783,36 @@ export class TicketDetailScreen extends AsyncScreen {
      * operator saw; a table whose `rows()` throws resolves to the error branch and
      * simply has no row to activate.
      */
+    /**
+     * GAIA-500 — `l`/`t`'s shared plumbing: resolve the active table's selected
+     * row and ask its `copyLocal`/`copyTunnel`, returning `undefined` when there
+     * is no active table, the table does not implement that side, or the row has
+     * nothing to offer — in every one of which cases the key is left UNHANDLED
+     * (the caller falls through) rather than reporting a copy that did not
+     * happen, exactly as `l`/`t` do nothing on every tab that is not a table.
+     */
+    copyActiveTableRow(context, side) {
+        const contribution = this.activeContribution(context);
+        if (contribution?.type !== 'table')
+            return;
+        const copyField = side === 'local' ? contribution.copyLocal : contribution.copyTunnel;
+        if (!copyField)
+            return;
+        const nowSeconds = context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
+        const resolved = this.tableView(contribution, context, {
+            expanded: new Set(),
+            nowSeconds,
+        });
+        if ('panelSections' in resolved)
+            return;
+        const row = resolved.panelTable.rows[this.selectedEntry];
+        if (!row)
+            return;
+        const value = copyField(row);
+        if (value === undefined)
+            return;
+        return copyThrough(context.copyToClipboard, value, value, 'nothing to copy');
+    }
     async activateTableRow(table, index, context, intent) {
         const nowSeconds = context.nowSeconds?.() ?? Math.floor(Date.now() / 1000);
         const resolved = this.tableView(table, context, {

package/dist/src/Entity/workspace/Screen/workspace-picker.js

@@ -7,10 +7,10 @@
 //
 // The switch does three things, in order, on Enter: (1) refuse silently when
 // the choice is already active — a write and a restart over "the same" would
-// be a no-op with side effects; (2) write the selection through the exact
-// helpers `gaia ui`'s startup recovery uses (`@gaia-ai/core`'s `workspaceOwner`
-// + `writeWorkspaceIdSelection`), so a manual edit and a cockpit switch commit
-// through the identical path and the identical ownership rule; (3) re-execute
+// be a no-op with side effects; (2) write the selection through `@gaia-ai/core`'s
+// `workspaceOwner` + `writeWorkspaceIdSelection`, the single ownership-and-write
+// path, so a manual edit and a cockpit switch commit through the identical path
+// and the identical ownership rule; (3) re-execute
 // this process via the seam `ui/src/bun-runtime.ts` exposes, so any conductor
 // reading the SAME config file re-binds on its next read.
 import { workspaceOwner, writeWorkspaceIdSelection } from '@gaia-ai/core';

package/dist/src/Extension/contract.d.ts

@@ -158,6 +158,22 @@ export interface UiTable<Row extends {
     onActivate?(row: Row, ctx: PanelRender): Promise<ActivationResult>;
     /** Shown when `rows` comes back empty. */
     readonly emptyMessage?: string;
+    /**
+     * GAIA-500 — what `l` copies for the selected row, when this table is the
+     * active tab: the LOCAL address, mirroring `s`/`x` (GAIA-475 UX), two
+     * distinct keys rather than one that means something different depending on
+     * state. Optional: a table with nothing local-shaped to copy leaves `l`
+     * unhandled here, and the key falls through inert — never a copy of
+     * something the row does not own.
+     */
+    copyLocal?(row: Row): string | undefined;
+    /**
+     * GAIA-500 — what `t` copies for the selected row: the address reached
+     * through the TUNNEL, when the row has one shared. `undefined` when nothing
+     * is shared — `t` on a `local only` row does nothing rather than copying an
+     * empty string or a stale value.
+     */
+    copyTunnel?(row: Row): string | undefined;
 }
 export type UiContribution = UiPanel | UiTable | UiScreen;
 /**

package/dist/src/types.d.ts

@@ -148,8 +148,8 @@ export interface RendererServices {
     workspace?: string;
     /**
      * GAIA-472 — the absolute path of the loaded connection config, so the
-     * workspace-picker screen can find `workspace_id`'s owning file the same way
-     * `gaia ui`'s startup recovery does (`@gaia-ai/core`'s `workspaceOwner`).
+     * workspace-picker screen can find `workspace_id`'s owning file through the
+     * shared ownership rule (`@gaia-ai/core`'s `workspaceOwner`).
      */
     configPath?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-ai/addon-gaia-ui",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "GAIA TUI: interactive terminal UI (dashboard, projects, tickets) as a dropsh `tui` renderer plugin.",
   "type": "module",
   "license": "MIT",
@@ -26,6 +26,6 @@
     "drupal-jsonapi-params": "^3.0.1"
   },
   "peerDependencies": {
-    "@gaia-ai/core": "^0.13.0"
+    "@gaia-ai/core": "^0.13.1"
   }
 }