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

package/dist/src/Component/footer-actions/index.d.ts

@@ -0,0 +1,58 @@
+import { type VNode } from '@opentui/core';
+/**
+ * One footer action — the atomic chip screens publish.
+ * Rendered as `key` ({@link FOREGROUND_ACTIVE} fg) plus optional muted `:Label`.
+ */
+export interface ActionItem {
+    /** Stable id — nodes are `${id}-key` / `${id}-sfx`. */
+    id: string;
+    /** Active key glyph, e.g. `e`, `Tab`, `→`. */
+    key: string;
+    /**
+     * Plain label without a colon (`edit`, `next`). Title-cased and prefixed
+     * with `:` at render time. Omit for a bare key (`Enter`).
+     */
+    label?: string;
+}
+/** Build an {@link ActionItem} — the usual screen-side constructor. */
+export declare const actionItem: (id: string, key: string, label?: string) => ActionItem;
+/** Legacy ladder string for assertions (`n new · e edit`). */
+export declare const formatActionLadder: (items: readonly ActionItem[] | undefined) => string;
+/** Box-drawing pipe — sits optically higher than ASCII `|`. */
+export declare const footerSep: (id: string) => VNode;
+/**
+ * Render one action-item as FOREGROUND_ACTIVE-fg key + optional muted `:Label`.
+ * Also used by the kernel basics row (`Esc:back`, `q:quit`).
+ */
+export declare const renderActionItem: (item: Pick<ActionItem, "id" | "key" | "label"> & {
+    suffix?: string;
+}) => VNode[];
+/**
+ * Low-level chip used by kernel basics that already pass a ready `:suffix`
+ * (e.g. `:quit`). Screen actions prefer {@link actionItem}.
+ */
+export declare const footerKey: (id: string, key: string, suffix?: string) => VNode[];
+/**
+ * A segment inside {@link withActionPipes}: an {@link ActionItem}, or already
+ * rendered nodes (plain text, {@link footerKey} chips, …).
+ */
+export type ActionSegment = ActionItem | readonly VNode[];
+/**
+ * Wrapper that inserts `│` between segments — action-items or prebuilt node
+ * groups. Callers never place separators by hand.
+ */
+export declare const withActionPipes: (sepIdPrefix: string, segments: readonly ActionSegment[]) => VNode[];
+/** Pipe-joined chips from an action-item list (thin wrapper over {@link withActionPipes}). */
+export declare const footerActionChips: (items: readonly ActionItem[], sepIdPrefix?: string) => VNode[];
+/**
+ * Full screen-actions row: lead pad + piped action-items + width pad.
+ * Returns `null` when `items` is empty — caller omits the row.
+ */
+export declare const footerActions: (id: string, items: readonly ActionItem[], width: number) => VNode | null;
+/** @deprecated Use {@link footerActions}. */
+export declare const footerActionsRow: (id: string, items: readonly ActionItem[], width: number) => VNode | null;
+/**
+ * Parse a legacy ladder string (`n new · e edit`) into action-items.
+ * Prefer publishing {@link ActionItem} arrays from screens directly.
+ */
+export declare const parseFooterLadder: (ladder: string, idPrefix?: string) => ActionItem[];

package/dist/src/Component/footer-actions/index.js

@@ -0,0 +1,111 @@
+// GAIA-375 — footer actions: action-item chips + withActionPipes (│ between them).
+// No footer fill — chips sit on the terminal default (same as header).
+import { BoxRenderable, h } from '@opentui/core';
+import { BORDER, FOREGROUND_ACTIVE, textNode } from '../../lib/vnode.js';
+/** Build an {@link ActionItem} — the usual screen-side constructor. */
+export const actionItem = (id, key, label) => (label === undefined ? { id, key } : { id, key, label });
+/** Legacy ladder string for assertions (`n new · e edit`). */
+export const formatActionLadder = (items) => (items ?? [])
+    .map((item) => item.label !== undefined ? `${item.key} ${item.label}` : item.key)
+    .join(' · ');
+/** Box-drawing pipe — sits optically higher than ASCII `|`. */
+export const footerSep = (id) => textNode({ id, content: ' │ ', fg: BORDER });
+/** First letter upper for labels (`edit` → `Edit`). */
+const titleCase = (label) => label.length === 0 ? label : label.charAt(0).toUpperCase() + label.slice(1);
+/**
+ * Render one action-item as FOREGROUND_ACTIVE-fg key + optional muted `:Label`.
+ * Also used by the kernel basics row (`Esc:back`, `q:quit`).
+ */
+export const renderActionItem = (item) => {
+    const suffix = item.suffix ??
+        (item.label !== undefined ? `:${titleCase(item.label)}` : undefined);
+    const nodes = [
+        textNode({
+            id: `${item.id}-key`,
+            content: item.key,
+            fg: FOREGROUND_ACTIVE,
+            bold: true,
+        }),
+    ];
+    if (suffix !== undefined) {
+        nodes.push(textNode({
+            id: `${item.id}-sfx`,
+            content: suffix,
+            fg: BORDER,
+        }));
+    }
+    return nodes;
+};
+/**
+ * Low-level chip used by kernel basics that already pass a ready `:suffix`
+ * (e.g. `:quit`). Screen actions prefer {@link actionItem}.
+ */
+export const footerKey = (id, key, suffix) => suffix === undefined
+    ? renderActionItem({ id, key })
+    : renderActionItem({ id, key, suffix });
+const isActionItem = (segment) => !Array.isArray(segment);
+/**
+ * Wrapper that inserts `│` between segments — action-items or prebuilt node
+ * groups. Callers never place separators by hand.
+ */
+export const withActionPipes = (sepIdPrefix, segments) => {
+    const parts = [];
+    let placed = 0;
+    for (const segment of segments) {
+        const nodes = isActionItem(segment)
+            ? renderActionItem(segment)
+            : [...segment];
+        if (nodes.length === 0)
+            continue;
+        if (placed > 0)
+            parts.push(footerSep(`${sepIdPrefix}-${placed}`));
+        parts.push(...nodes);
+        placed += 1;
+    }
+    return parts;
+};
+/** Pipe-joined chips from an action-item list (thin wrapper over {@link withActionPipes}). */
+export const footerActionChips = (items, sepIdPrefix = 'footer-actions-sep') => withActionPipes(sepIdPrefix, items);
+/**
+ * Full screen-actions row: lead pad + piped action-items + width pad.
+ * Returns `null` when `items` is empty — caller omits the row.
+ */
+export const footerActions = (id, items, width) => {
+    if (items.length === 0)
+        return null;
+    return h(BoxRenderable, {
+        id,
+        flexDirection: 'row',
+        height: 1,
+        flexShrink: 0,
+        width: '100%',
+    }, textNode({
+        id: `${id}-lead`,
+        content: ' ',
+    }), ...withActionPipes(`${id}-sep`, items), textNode({
+        id: `${id}-pad`,
+        content: ' '.repeat(width),
+    }));
+};
+/** @deprecated Use {@link footerActions}. */
+export const footerActionsRow = footerActions;
+/**
+ * Parse a legacy ladder string (`n new · e edit`) into action-items.
+ * Prefer publishing {@link ActionItem} arrays from screens directly.
+ */
+export const parseFooterLadder = (ladder, idPrefix = 'footer-action') => {
+    const segments = ladder
+        .split(/\s·\s/)
+        .map((s) => s.trim())
+        .filter((s) => s !== '');
+    const items = [];
+    for (let i = 0; i < segments.length; i += 1) {
+        const m = /^(\S+)(?:\s+(.+))?$/.exec(segments[i]);
+        if (m === null)
+            continue;
+        const key = m[1];
+        const label = m[2];
+        items.push(actionItem(`${idPrefix}-${i}`, key, label));
+    }
+    return items;
+};

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

@@ -0,0 +1,19 @@
+import { type VNode } from '@opentui/core';
+/** One filter/action badge in the strip above a list table. */
+export interface ListFilterBadge {
+    /** Stable id suffix — node id is `${stripId}-${id}`. */
+    id: string;
+    /** Idle label (key hint), e.g. `/ search` or `x closed`. */
+    label: string;
+    /**
+     * When set, the badge is active: {@link FOREGROUND_ACTIVE} fg and this value text
+     * (e.g. `closed: hidden`, `who: cw`).
+     */
+    value?: string;
+}
+/**
+ * Rounded filter chips in a row (idle outline + active FOREGROUND_ACTIVE fg).
+ * Each badge is its own `borderStyle: 'rounded'` box — the panel border language.
+ * Horizontal inset matches the body ScrollBox frame padding (GAIA-375).
+ */
+export declare const filterBadgeStrip: (id: string, badges: readonly ListFilterBadge[]) => VNode;

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

@@ -0,0 +1,61 @@
+// GAIA-375 — shared full-screen body helpers: optional filter badges.
+// Body frame lives on region-body ScrollBox (Kernel/regions.ts).
+import { BoxRenderable, h } from '@opentui/core';
+import { BACKGROUND_ACTIVE, BORDER, DEFAULT_BACKGROUND, FOREGROUND, FOREGROUND_ACTIVE, textNode, } from '../../lib/vnode.js';
+/**
+ * Rounded filter chips in a row (idle outline + active FOREGROUND_ACTIVE fg).
+ * Each badge is its own `borderStyle: 'rounded'` box — the panel border language.
+ * Horizontal inset matches the body ScrollBox frame padding (GAIA-375).
+ */
+export const filterBadgeStrip = (id, badges) => {
+    const nodes = [];
+    for (let index = 0; index < badges.length; index += 1) {
+        if (index > 0) {
+            nodes.push(textNode({
+                id: `${id}-gap-${index}`,
+                content: '  ',
+                bg: DEFAULT_BACKGROUND,
+                fg: BORDER,
+            }));
+        }
+        const badge = badges[index];
+        const value = badge.value;
+        const active = value !== undefined && value !== '';
+        const label = active ? value : badge.label;
+        nodes.push(h(BoxRenderable, {
+            id: `${id}-${badge.id}-chip`,
+            border: true,
+            borderStyle: 'rounded',
+            borderColor: BORDER,
+            backgroundColor: DEFAULT_BACKGROUND,
+            flexShrink: 0,
+            // One extra column of air inside the pill (rounder optical mass).
+            paddingLeft: 2,
+            paddingRight: 2,
+            flexDirection: 'row',
+        }, textNode({
+            id: `${id}-${badge.id}`,
+            content: label,
+            bg: active ? BACKGROUND_ACTIVE : DEFAULT_BACKGROUND,
+            fg: active ? FOREGROUND_ACTIVE : FOREGROUND,
+        })));
+    }
+    return h(BoxRenderable, {
+        id,
+        backgroundColor: DEFAULT_BACKGROUND,
+        flexDirection: 'column',
+        flexShrink: 0,
+        // Match body ScrollBox horizontal inset (GAIA-375).
+        paddingLeft: 1,
+        paddingRight: 1,
+        paddingTop: 0,
+        paddingBottom: 0,
+    }, h(BoxRenderable, {
+        id: `${id}-row`,
+        flexDirection: 'row',
+        flexWrap: 'wrap',
+        flexShrink: 0,
+        backgroundColor: DEFAULT_BACKGROUND,
+        gap: 0,
+    }, ...nodes));
+};

package/dist/src/Component/markdown/index.d.ts

@@ -0,0 +1,68 @@
+import type { MarkdownLine, MarkdownSpan } from '../../lib/markdown.js';
+import { type StyledLine, type StyledRun } from '../../lib/vnode.js';
+/**
+ * ONE SPAN AS THE RUN A RENDERER CAN PAINT — D7/D11, and the mapping this
+ * component owns.
+ *
+ * `bold`, `italic` and `dim` are ATTRIBUTES and OR together into one bitmask;
+ * `code` is a COLOUR and not an attribute at all, which is why a code span that
+ * is also emphasised carries both. The colour is {@link BORDER} (indexed, same
+ * slot as ordinary foreground after GAIA-375 dropped cyan) — never a truecolor
+ * triplet.
+ *
+ * `strikethrough` and `underline` are deliberately absent: underline is what a
+ * terminal hyperlink looks like and would collide with D6's `text (url)`, and
+ * `~~struck~~` is mapped onto `dim` rather than widening the wire vocabulary a
+ * second time for a construct GAIA bodies barely use.
+ */
+export declare const styledRunOf: (span: MarkdownSpan) => StyledRun;
+/**
+ * ONE PARSED LINE AS A NEUTRAL STYLED LINE.
+ *
+ * `text` is carried through UNTOUCHED — that is the pipe constraint in one line
+ * of code. The styling step may not change a glyph, and it cannot: it only ever
+ * reads a span's flags.
+ */
+export declare const styledLineOf: (line: MarkdownLine) => StyledLine;
+/** A `gaia_rich` body as the physical rows a surface draws or prints — D1. */
+export declare function markdownLines(body: string): StyledLine[];
+/** A line NOTHING parses — one unstyled run (D3's plain path, as a value). */
+export declare function plainLine(text: string): StyledLine;
+/**
+ * The same line held `columns` in from the left — D5.
+ *
+ * The indent is an unstyled run PREPENDED TO A RENDERED LINE, never four spaces
+ * prepended to the source — see this file's header for why that ordering is
+ * load-bearing rather than tidy.
+ */
+export declare function indentLine(source: StyledLine, columns: number): StyledLine;
+/**
+ * THE RUN LOG'S OWN MINIMAL RULE — GAIA-372 D9, and it has exactly ONE caller:
+ * `Entity/run/Component/run-detail`.
+ *
+ * An ATX heading (`#`…`######`) renders as bold with the markers stripped;
+ * everything else is returned unchanged. Bullets, emphasis and code fences stay
+ * raw.
+ *
+ * ITS DOC COMMENT ONCE CLAIMED THE OPPOSITE OF WHAT IS NOW TRUE — that it is "ONE
+ * function, because every renderer of a body line goes through it". Since
+ * GAIA-372 no body line goes through it at all: a `gaia_rich` body is rendered by
+ * {@link markdownLines} and reaches a row as a `StyledLine` (D3), and
+ * `Component/section-list`'s `sectionRows`/`expandableRows` do not parse a plain
+ * string.
+ *
+ * IT LIVED IN `Component/section-list` UNTIL D11 MOVED IT HERE. That was where it
+ * sat while it really was the rule for EVERY body row; once it was not, all it left
+ * behind was a Markdown rule inside a generic list primitive. The rule is unchanged,
+ * character for character; only its address is.
+ *
+ * The run log keeps the narrow rule DELIBERATELY, not by omission. A log entry is
+ * MACHINE OUTPUT, not authored Markdown: an agent line full of `*`, `_` and
+ * backticks would be re-styled and have characters deleted by a renderer meant
+ * for prose. Routing the log through the full subset is a separate ticket, not a
+ * silent side effect of this one.
+ */
+export declare function markdownRow(line: string): {
+    text: string;
+    bold: boolean;
+};

package/dist/src/Component/markdown/index.js

@@ -0,0 +1,133 @@
+// THE MARKDOWN COMPONENT — GAIA-372 D11, and the one place the cockpit knows
+// what Markdown is.
+//
+// WHY IT EXISTS. Markdown arrived in this package as two halves that landed in
+// two wrong places. `lib/markdown.ts` is a pure parser and belongs where it is,
+// but the STYLING half — which span kind means which terminal attribute and which
+// palette colour — ended up inside `lib/vnode.ts`, the package's most-shared
+// render primitive, the one twelve screens draw through. `Component/section-list`
+// then named `MarkdownLine`/`MarkdownSpan` throughout its own contract. So a
+// generic node vocabulary and a generic list primitive both carried Markdown
+// domain knowledge, and no gate caught it: `scripts/assert-acyclic.mjs` enforces
+// PACKAGE layering, and both files live in `lib/`.
+//
+// THE SHAPE. This directory owns all of it, and the import direction inverts:
+//
+//   Component/markdown  →  lib/vnode   (attributes, palette, the neutral run)
+//   Component/markdown  →  lib/markdown (the pure parser, no @opentui/core)
+//   lib/vnode           →  nothing about Markdown
+//   Component/section-list → lib/vnode  (StyledLine, never MarkdownLine)
+//
+// THE HARD CONSTRAINT, and the reason this is not a paint-only component: the
+// non-interactive pipe prints `row.text` and NOTHING ELSE. AC-3's parity is
+// structural precisely because a rendered row carries its rendered TEXT, so
+// `gaia ui <id> | cat` and the interactive tree are the same rendering by
+// construction rather than by agreement (D4). A component that emitted only
+// VNodes would cut the pipe off that rendering and restore the
+// two-renderers-disagree defect this ticket exists to remove. So the output here
+// is DATA — a {@link StyledLine}: rendered text, resolved runs, and the row's own
+// weight — and `Component/section-list`'s `lineText` keeps working unchanged.
+//
+// WHY `plainLine` AND `indentLine` LIVE HERE rather than in the parser: neither
+// parses. `plainLine` is D3's plain path expressed as a value, and `indentLine`
+// prepends blanks to an ALREADY RENDERED line — which is the whole point of it
+// (four leading spaces prepended to SOURCE would be an indented code block in
+// CommonMark, so applying the indent after rendering is what makes that
+// impossible rather than merely unlikely, Fact 9). Both are shell work on a
+// rendered line, so they sit with the shell.
+import { markdownLines as parseMarkdown } from '../../lib/markdown.js';
+import { BOLD, BORDER, DIM, ITALIC, } from '../../lib/vnode.js';
+/**
+ * ONE SPAN AS THE RUN A RENDERER CAN PAINT — D7/D11, and the mapping this
+ * component owns.
+ *
+ * `bold`, `italic` and `dim` are ATTRIBUTES and OR together into one bitmask;
+ * `code` is a COLOUR and not an attribute at all, which is why a code span that
+ * is also emphasised carries both. The colour is {@link BORDER} (indexed, same
+ * slot as ordinary foreground after GAIA-375 dropped cyan) — never a truecolor
+ * triplet.
+ *
+ * `strikethrough` and `underline` are deliberately absent: underline is what a
+ * terminal hyperlink looks like and would collide with D6's `text (url)`, and
+ * `~~struck~~` is mapped onto `dim` rather than widening the wire vocabulary a
+ * second time for a construct GAIA bodies barely use.
+ */
+export const styledRunOf = (span) => ({
+    text: span.text,
+    attributes: (span.bold === true ? BOLD : 0) |
+        (span.italic === true ? ITALIC : 0) |
+        (span.dim === true ? DIM : 0),
+    // Spread rather than `fg: undefined`, for `exactOptionalPropertyTypes`: an
+    // unstyled run must state no colour, so `lib/vnode.ts`'s early exit can still
+    // hand the plain string straight to the renderable.
+    ...(span.code === true ? { fg: BORDER } : {}),
+});
+/**
+ * ONE PARSED LINE AS A NEUTRAL STYLED LINE.
+ *
+ * `text` is carried through UNTOUCHED — that is the pipe constraint in one line
+ * of code. The styling step may not change a glyph, and it cannot: it only ever
+ * reads a span's flags.
+ */
+export const styledLineOf = (line) => ({
+    text: line.text,
+    runs: line.spans.map(styledRunOf),
+    heading: line.heading,
+});
+/** A `gaia_rich` body as the physical rows a surface draws or prints — D1. */
+export function markdownLines(body) {
+    return parseMarkdown(body).map(styledLineOf);
+}
+/** A line NOTHING parses — one unstyled run (D3's plain path, as a value). */
+export function plainLine(text) {
+    return {
+        text,
+        runs: text === '' ? [] : [{ text, attributes: 0 }],
+        heading: false,
+    };
+}
+/**
+ * The same line held `columns` in from the left — D5.
+ *
+ * The indent is an unstyled run PREPENDED TO A RENDERED LINE, never four spaces
+ * prepended to the source — see this file's header for why that ordering is
+ * load-bearing rather than tidy.
+ */
+export function indentLine(source, columns) {
+    const blanks = ' '.repeat(columns);
+    return {
+        text: `${blanks}${source.text}`,
+        runs: [{ text: blanks, attributes: 0 }, ...source.runs],
+        heading: source.heading,
+    };
+}
+/**
+ * THE RUN LOG'S OWN MINIMAL RULE — GAIA-372 D9, and it has exactly ONE caller:
+ * `Entity/run/Component/run-detail`.
+ *
+ * An ATX heading (`#`…`######`) renders as bold with the markers stripped;
+ * everything else is returned unchanged. Bullets, emphasis and code fences stay
+ * raw.
+ *
+ * ITS DOC COMMENT ONCE CLAIMED THE OPPOSITE OF WHAT IS NOW TRUE — that it is "ONE
+ * function, because every renderer of a body line goes through it". Since
+ * GAIA-372 no body line goes through it at all: a `gaia_rich` body is rendered by
+ * {@link markdownLines} and reaches a row as a `StyledLine` (D3), and
+ * `Component/section-list`'s `sectionRows`/`expandableRows` do not parse a plain
+ * string.
+ *
+ * IT LIVED IN `Component/section-list` UNTIL D11 MOVED IT HERE. That was where it
+ * sat while it really was the rule for EVERY body row; once it was not, all it left
+ * behind was a Markdown rule inside a generic list primitive. The rule is unchanged,
+ * character for character; only its address is.
+ *
+ * The run log keeps the narrow rule DELIBERATELY, not by omission. A log entry is
+ * MACHINE OUTPUT, not authored Markdown: an agent line full of `*`, `_` and
+ * backticks would be re-styled and have characters deleted by a renderer meant
+ * for prose. Routing the log through the full subset is a separate ticket, not a
+ * silent side effect of this one.
+ */
+export function markdownRow(line) {
+    const md = /^(#{1,6})\s+(.*)$/.exec(line);
+    return md ? { text: md[2] ?? '', bold: true } : { text: line, bold: false };
+}

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

@@ -1,5 +1,5 @@
 import type { VNode } from '@opentui/core';
-import { type Cell } from '../../lib/vnode.js';
+import { type Cell, type StyledLine, type StyledRun } from '../../lib/vnode.js';
 /**
  * A section body row that is COLUMNS rather than prose — GAIA-340 Task 13.
  *
@@ -14,8 +14,35 @@ import { type Cell } from '../../lib/vnode.js';
 export interface SectionCells {
     readonly cells: readonly Cell[];
 }
-/** One body row of a section: prose, or columns a renderer places itself. */
-export type SectionLine = string | SectionCells;
+/**
+ * One body row of a section — GAIA-372 D3, where the third variant arrived.
+ *
+ * A body DECLARES ITSELF MARKDOWN; a plain string stays plain:
+ *
+ *  - a `string` is PLAIN TEXT, rendered verbatim and **never parsed**;
+ *  - a {@link SectionCells} is columns, unchanged (a run number opens with `#`);
+ *  - a {@link StyledLine} is an ALREADY RENDERED body row, carrying its styled
+ *    runs and its `heading` flag.
+ *
+ * GAIA-372 D11 — the third variant is NEUTRAL. It used to be `MarkdownLine`, which
+ * made this generic list primitive name a domain it does not own; a producer of
+ * styled rows is not necessarily a Markdown renderer, and `Component/markdown/` is
+ * where that domain lives now.
+ *
+ * That is what makes AC-5 STRUCTURAL rather than careful. `Assignment`, `Time`,
+ * `Branch`, `Links`, `Labels` and the run table hand over plain strings, so no
+ * Markdown rule can reach them — a branch called `feat/a_b_c` or a link title
+ * holding a `*` cannot be re-styled or re-spelled by a parser that never sees it.
+ * It is also strictly LESS parsing than before GAIA-372, when
+ * `Component/markdown/`'s `markdownRow` ran over every one of those rows.
+ *
+ * The rejected alternative was a block-aware pass inside {@link sectionRows} over
+ * `section.lines`, for exactly that reason: it would run the renderer over every
+ * non-Markdown section, and the flat `Comments` section would run one stateful
+ * pass across ALL comments' bodies, letting an unterminated fence in one comment
+ * swallow the next.
+ */
+export type SectionLine = string | SectionCells | StyledLine;
 /**
  * A line as the text a surface with no layout prints.
  *
@@ -23,29 +50,29 @@ export type SectionLine = string | SectionCells;
  * 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 declare const lineText: (line: SectionLine) => string;
+/**
+ * Any body line as a RENDERED line — GAIA-372 D3/D8.
+ *
+ * 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 declare const styledOf: (line: SectionLine) => StyledLine;
 /** A titled block of already-flattened physical rows. */
 export interface Section {
     heading: string;
     lines: SectionLine[];
 }
-/**
- * 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).
- *
- * 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.
- */
-export declare function markdownRow(line: string): {
-    text: string;
-    bold: boolean;
-};
 /**
  * One flattened row: its text, whether it is bold, and WHICH ROW IT IS
  * (GAIA-340 D3/D4).
@@ -69,6 +96,17 @@ export interface SectionRow {
      * where the difference is made.
      */
     readonly cells?: readonly Cell[];
+    /**
+     * The row's STYLED RUNS, for a row that carries per-run styling — GAIA-372
+     * D5/D11.
+     *
+     * Absent means everything is exactly as it was: one attribute set for the whole
+     * row. `text` is the same row for a surface that cannot paint a run, so the
+     * pipe never has to know the difference (D4). Already-resolved attributes and
+     * colours: WHICH run asks for which is `Component/markdown/`'s business, not
+     * this primitive's.
+     */
+    readonly runs?: readonly StyledRun[];
 }
 /**
  * A heading as an id fragment: `PER USER` → `per-user`.
@@ -79,6 +117,55 @@ export interface SectionRow {
  * it, and `patchTree` would rebuild it instead of writing to it (GAIA-340 D4).
  */
 export declare const sectionKey: (heading: string) => string;
+/**
+ * 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 declare const panelSectionKey: (heading: string) => string;
 /**
  * Flatten `{heading, lines}` sections into KEYED rows: the heading, its body,
  * and the blank line that closes the section.
@@ -89,7 +176,7 @@ export declare const sectionKey: (heading: string) => string;
  * property that lets the Dashboard hand over renderables while its pipe keeps
  * emitting the bytes it always did (spec F5).
  */
-export declare function sectionRows(sections: Section[]): SectionRow[];
+export declare function sectionRows(sections: Section[], keyOf?: (heading: string) => string): SectionRow[];
 /**
  * One flattened row as the node a converted screen hands over — GAIA-340 D1.
  *
@@ -120,10 +207,15 @@ export interface ExpandableEntry {
     key: string;
     /** The header row's text, after the caret. */
     header: string;
-    /** Rows shown while collapsed (indented like the expanded body). */
-    collapsed: string[];
+    /**
+     * Rows shown while collapsed (indented like the expanded body).
+     *
+     * GAIA-372 D3 — a {@link SectionLine}, so a rendered body row keeps its runs
+     * on this surface too and a plain string is still never parsed.
+     */
+    collapsed: SectionLine[];
     /** Rows shown while expanded. */
-    expanded: string[];
+    expanded: SectionLine[];
 }
 /** The rendered rows of a list of expandable entries. */
 export interface ExpandableView {