@datalayer/agent-runtimes 1.5.89 → 1.5.91

package/lib/components/teams/transcript/transcriptDetailRules.d.ts

@@ -0,0 +1,80 @@
+/**
+ * What a line's span says (SCENES S3-01): the words sent and the words
+ * answered, a tool's name, arguments and result when the span recorded
+ * them, when it started and ended, its status and an error's message, the
+ * span and trace ids; for a coding harness's step, the Shield's decision on
+ * it and the rule it decided by. Pure: a line and its span in, the detail out
+ * ({@link TranscriptDetail} draws it).
+ *
+ * @module components/teams/transcript/transcriptDetailRules
+ */
+import type { OtelSpan } from '@datalayer/core/lib/otel/types';
+import { type SceneTranscriptLine } from '../sceneTranscriptRules';
+/** The ids that name a span: what *Open in the Inspector* opens. */
+export type TranscriptSpanIds = {
+    traceId: string;
+    spanId: string;
+};
+/** What the Shield decided of a coding harness's step, from its events. */
+export type TranscriptShieldStep = {
+    /** `allow`, `ask` or `deny`: the last decision on the step. */
+    decision: string;
+    /** The decision in a person's words: *do it*, *ask me first*, *leave it to me*. */
+    said: string;
+    /** The rule it decided by: an application's Rule names it (*Change a file*). */
+    rule?: string;
+    /** The policy the rule is of: `team` (the application's Rules), `session` (the platform's default)… */
+    scope?: string;
+    /** Who decided: the policy, a person asked, the Shield. */
+    decidedBy?: string;
+    /** The harness's kind of step (`read`, `edit`, `execute`) and its class (`read`, `write`…). */
+    kind?: string;
+    actionClass?: string;
+    path?: string;
+    command?: string;
+    /** The harness, from the turn: `opencode`. */
+    harness?: string;
+};
+/** A decision, as a person reads it. */
+export declare const SHIELD_DECISION_WORDS: Record<string, string>;
+/** The detail of a line, from its span. */
+export type TranscriptDetailOf = {
+    line: SceneTranscriptLine;
+    /** None for a line read from a recording: there is no span to open. */
+    span?: OtelSpan;
+    /** The words sent: what was asked, or the tool called. */
+    sent?: string;
+    /** The words answered. */
+    answered?: string;
+    tool?: {
+        name: string;
+        arguments?: string;
+        result?: string;
+    };
+    /** A coding harness's step: what the Shield decided, and by which rule. */
+    shield?: TranscriptShieldStep;
+    startedAt?: number;
+    endedAt?: number;
+    durationMs?: number;
+    /** `running`, `ok`, `failed`, or the span's own code. */
+    status: string;
+    error?: string;
+    ids?: TranscriptSpanIds & {
+        parentSpanId?: string;
+    };
+};
+/** JSON, pretty when it parses; the text as it is otherwise. */
+export declare function prettyJson(value: unknown): string | undefined;
+/**
+ * The span a line was read from: the one whose id its key begins with — a
+ * harness's step names its turn's span and its call, `<span>/<call>`.
+ */
+export declare function spanOfLine(line: Pick<SceneTranscriptLine, 'key'>, spans: readonly OtelSpan[] | undefined): OtelSpan | undefined;
+/** What the Shield decided of the step a line is, from its turn's span; none for any other line. */
+export declare function shieldStepOf(line: Pick<SceneTranscriptLine, 'key'>, span: OtelSpan): TranscriptShieldStep | undefined;
+/** The sentence for a step the Shield refused. */
+export declare function shieldRefusalText(step: TranscriptShieldStep): string;
+/** The detail of a line: from its span when there is one. */
+export declare function transcriptDetailOf(line: SceneTranscriptLine, span?: OtelSpan): TranscriptDetailOf;
+/** The sentence for a line with no span: a recording. */
+export declare const NO_SPAN_TEXT = "This line comes from a recording: there is no span to open.";

package/lib/components/teams/transcript/transcriptDetailRules.js

@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { isShieldTurn, SHIELD_STEP_EVENTS, stepCallOf, } from '../sceneTranscriptRules.js';
+import { exchangeOf } from './transcriptRows.js';
+/** A decision, as a person reads it. */
+export const SHIELD_DECISION_WORDS = {
+    allow: 'do it',
+    ask: 'ask me first',
+    deny: 'leave it to me',
+};
+const text = (value) => typeof value === 'string' && value.trim() ? value : undefined;
+/** JSON, pretty when it parses; the text as it is otherwise. */
+export function prettyJson(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        return JSON.stringify(value, null, 2);
+    }
+    try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        return value;
+    }
+}
+/** The text of a GenAI messages attribute (JSON), every message's parts. */
+function messagesText(value) {
+    const raw = text(value);
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const words = parsed
+            .flatMap(message => message.parts ?? [])
+            .map(part => (typeof part.content === 'string' ? part.content : ''))
+            .filter(Boolean)
+            .join('\n\n')
+            .trim();
+        return words || undefined;
+    }
+    catch {
+        return raw;
+    }
+}
+const millis = (iso) => {
+    const parsed = iso ? Date.parse(iso) : Number.NaN;
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+/**
+ * The span a line was read from: the one whose id its key begins with — a
+ * harness's step names its turn's span and its call, `<span>/<call>`.
+ */
+export function spanOfLine(line, spans) {
+    const id = exchangeOf(line.key);
+    return spans?.find(span => span.span_id === id || id.startsWith(`${span.span_id}/`));
+}
+/** What the Shield decided of the step a line is, from its turn's span; none for any other line. */
+export function shieldStepOf(line, span) {
+    if (!isShieldTurn(span)) {
+        return undefined;
+    }
+    const exchange = exchangeOf(line.key);
+    const call = exchange.slice(span.span_id.length + 1);
+    let found;
+    for (const event of span.events ?? []) {
+        if (!SHIELD_STEP_EVENTS.includes(event.name) ||
+            stepCallOf(event) !== call) {
+            continue;
+        }
+        const attributes = event.attributes ?? {};
+        const decision = text(attributes.decision);
+        const step = found ?? {
+            decision: '',
+            said: '',
+        };
+        // A refusal stands: what the Shield did after it (a completion row) does not undo it.
+        if (decision && step.decision !== 'deny') {
+            step.decision = decision;
+            step.said = SHIELD_DECISION_WORDS[decision] ?? decision;
+            step.rule = text(attributes.rule) ?? step.rule;
+            step.scope = text(attributes.scope) ?? step.scope;
+            step.decidedBy =
+                text(attributes.decided_by) ?? text(attributes.by) ?? step.decidedBy;
+        }
+        step.kind = step.kind ?? text(attributes.kind);
+        step.actionClass = step.actionClass ?? text(attributes.class);
+        step.path = step.path ?? text(attributes.path);
+        step.command = step.command ?? text(attributes.command);
+        found = step;
+    }
+    if (!found) {
+        return undefined;
+    }
+    const harness = text(span.attributes?.['shield.harness']);
+    return Object.fromEntries(Object.entries({ ...found, harness }).filter(([, value]) => value !== undefined && value !== ''));
+}
+/** The sentence for a step the Shield refused. */
+export function shieldRefusalText(step) {
+    return step.rule
+        ? `Refused by the Shield: ${step.said}, by the rule '${step.rule}'${step.scope ? ` (${step.scope})` : ''}.`
+        : `Refused by the Shield: ${step.said}.`;
+}
+/** The detail of a line: from its span when there is one. */
+export function transcriptDetailOf(line, span) {
+    if (!span) {
+        return {
+            line,
+            status: line.open ? 'running' : line.failed ? 'failed' : 'done',
+        };
+    }
+    const shield = shieldStepOf(line, span);
+    if (shield) {
+        // A harness's step: its turn's span holds every step, so the times are the line's.
+        const refused = shield.decision === 'deny';
+        return {
+            line,
+            span,
+            sent: line.text,
+            shield,
+            startedAt: line.at,
+            endedAt: line.ended,
+            durationMs: line.ended === undefined
+                ? undefined
+                : Math.max(0, line.ended - line.at),
+            status: line.open ? 'running' : refused || line.failed ? 'failed' : 'ok',
+            error: refused ? shieldRefusalText(shield) : undefined,
+            ids: {
+                traceId: span.trace_id,
+                spanId: span.span_id,
+                ...(span.parent_span_id ? { parentSpanId: span.parent_span_id } : {}),
+            },
+        };
+    }
+    const attributes = span.attributes ?? {};
+    const operation = attributes['gen_ai.operation.name'];
+    const startedAt = millis(span.start_time);
+    const endedAt = span.in_progress ? undefined : millis(span.end_time);
+    const durationMs = span.in_progress || startedAt === undefined || endedAt === undefined
+        ? undefined
+        : Math.max(0, endedAt - startedAt);
+    const status = span.in_progress
+        ? 'running'
+        : span.status_code === 'ERROR'
+            ? 'failed'
+            : span.status_code === 'OK' || !span.status_code
+                ? 'ok'
+                : span.status_code.toLowerCase();
+    const error = span.status_code === 'ERROR'
+        ? (text(span.status_message) ??
+            text(attributes['error.type']) ??
+            'failed')
+        : undefined;
+    const ids = {
+        traceId: span.trace_id,
+        spanId: span.span_id,
+        ...(span.parent_span_id ? { parentSpanId: span.parent_span_id } : {}),
+    };
+    const base = {
+        line,
+        span,
+        startedAt,
+        endedAt,
+        durationMs,
+        status,
+        error,
+        ids,
+    };
+    if (operation === 'execute_tool') {
+        const name = text(attributes['gen_ai.tool.name']) ?? line.text;
+        return {
+            ...base,
+            sent: name,
+            tool: {
+                name,
+                arguments: prettyJson(attributes['gen_ai.tool.call.arguments']),
+                result: prettyJson(attributes['gen_ai.tool.call.result']),
+            },
+        };
+    }
+    if (operation === 'invoke_agent') {
+        return {
+            ...base,
+            sent: messagesText(attributes['gen_ai.input.messages']),
+            answered: messagesText(attributes['gen_ai.output.messages']),
+        };
+    }
+    // An A2A request: its words, and what came back.
+    let answered = text(attributes['a2a.answer.text']);
+    if (!answered) {
+        for (const event of span.events ?? []) {
+            if (event.name === 'a2a.message' ||
+                event.name === 'a2a.artifact_update') {
+                answered = text(event.attributes?.['a2a.message.text']) ?? answered;
+            }
+        }
+    }
+    return {
+        ...base,
+        sent: text(attributes['a2a.message.text']),
+        answered,
+    };
+}
+/** The sentence for a line with no span: a recording. */
+export const NO_SPAN_TEXT = 'This line comes from a recording: there is no span to open.';

package/lib/components/teams/transcript/transcriptExport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The transcript as a JSON file (SCENES S3-03): the lines as they are,
+ * under a version, so that `agent_runtimes` reads them back in Python
+ * (`loop/scenes/transcript.py`, `lines_of_json`) and a problem seen on a
+ * stage is replayed in a test.
+ *
+ * @module components/teams/transcript/transcriptExport
+ */
+import type { SceneTranscriptLine } from '../sceneTranscriptRules';
+/** The file's version: refused when another is read. */
+export declare const TRANSCRIPT_JSON_VERSION = 1;
+/** What the file holds. */
+export type TranscriptJson = {
+    version: typeof TRANSCRIPT_JSON_VERSION;
+    /** When it was exported, ISO. */
+    exported: string;
+    /** The scene, by id, when known. */
+    scene?: string;
+    lines: SceneTranscriptLine[];
+};
+/** The lines as JSON text, two spaces in. */
+export declare function transcriptJson(lines: readonly SceneTranscriptLine[], options?: {
+    scene?: string;
+    now?: () => number;
+}): string;
+/** The lines of a file written by {@link transcriptJson}; a sentence for anything else. */
+export declare function linesOfTranscriptJson(text: string): SceneTranscriptLine[];
+/** The file's name: `<scene>-transcript.json`, or `transcript.json`. */
+export declare function transcriptFileName(scene?: string): string;
+/** Hands the browser a file to save: a link to a blob, clicked. */
+export declare function downloadText(name: string, text: string, type?: string): void;

package/lib/components/teams/transcript/transcriptExport.js

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The file's version: refused when another is read. */
+export const TRANSCRIPT_JSON_VERSION = 1;
+/** The lines as JSON text, two spaces in. */
+export function transcriptJson(lines, options = {}) {
+    const now = options.now ?? Date.now;
+    const file = {
+        version: TRANSCRIPT_JSON_VERSION,
+        exported: new Date(now()).toISOString(),
+        ...(options.scene ? { scene: options.scene } : {}),
+        lines: lines.map(line => ({ ...line })),
+    };
+    return `${JSON.stringify(file, null, 2)}\n`;
+}
+const KINDS = new Set(['said', 'asked', 'called']);
+/** The lines of a file written by {@link transcriptJson}; a sentence for anything else. */
+export function linesOfTranscriptJson(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error('The transcript file is not JSON.');
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('The transcript file is not an object.');
+    }
+    const file = parsed;
+    if (file.version !== TRANSCRIPT_JSON_VERSION) {
+        throw new Error(`The transcript file is version ${String(file.version)}; this reads version ${TRANSCRIPT_JSON_VERSION}.`);
+    }
+    if (!Array.isArray(file.lines)) {
+        throw new Error('The transcript file has no lines.');
+    }
+    return file.lines.map((line, index) => {
+        const at = line;
+        if (typeof at.key !== 'string' ||
+            typeof at.at !== 'number' ||
+            typeof at.from !== 'string' ||
+            typeof at.text !== 'string' ||
+            !KINDS.has(String(at.kind))) {
+            throw new Error(`Line ${index + 1} of the transcript file is not a line.`);
+        }
+        return {
+            key: at.key,
+            at: at.at,
+            from: at.from,
+            ...(typeof at.to === 'string' ? { to: at.to } : {}),
+            kind: at.kind,
+            text: at.text,
+            ...(at.open ? { open: true } : {}),
+            ...(at.failed ? { failed: true } : {}),
+            ...(typeof at.ended === 'number' ? { ended: at.ended } : {}),
+        };
+    });
+}
+/** The file's name: `<scene>-transcript.json`, or `transcript.json`. */
+export function transcriptFileName(scene) {
+    const slug = (scene ?? '')
+        .replace(/[^a-z0-9-]+/gi, '-')
+        .replace(/^-|-$/g, '');
+    return slug ? `${slug}-transcript.json` : 'transcript.json';
+}
+/** Hands the browser a file to save: a link to a blob, clicked. */
+export function downloadText(name, text, type = 'application/json') {
+    const document = globalThis.document;
+    if (!document || typeof URL.createObjectURL !== 'function') {
+        return;
+    }
+    const url = URL.createObjectURL(new Blob([text], { type }));
+    const anchor = document.createElement('a');
+    anchor.href = url;
+    anchor.download = name;
+    anchor.rel = 'noopener';
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+}

package/lib/components/teams/transcript/transcriptRows.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The transcript as rows (SCENES S2-01): one row per line, with what the
+ * lines do not say in so many words — over which protocol an exchange went,
+ * how long a call or an ask took, in what state it is — and the filter the
+ * three views share: members, kinds, *failed only*, failed first.
+ *
+ * Pure: lines in, rows out, so that a test reads a recorded transcript and
+ * the page draws a live one the same way ({@link TranscriptTable}).
+ *
+ * @module components/teams/transcript/transcriptRows
+ */
+import { type SceneTranscriptKind, type SceneTranscriptLine } from '../sceneTranscriptRules';
+/** Over what a line went: a member asked over A2A, a server called over MCP, a tool of the member's own. */
+export type TranscriptOver = 'a2a' | 'mcp' | 'tool';
+/** What a row is in: still happening, failed, or done. */
+export type TranscriptState = 'open' | 'failed' | 'done';
+/** One row of the table. */
+export type TranscriptRow = {
+    /** The line's key. */
+    id: string;
+    at: number;
+    from: string;
+    to?: string;
+    /** None for words said to all, or asked by the person. */
+    over?: TranscriptOver;
+    kind: SceneTranscriptKind;
+    text: string;
+    /** A call's, from its `called` to its answer; an ask's, from the question to the answer. None while open. */
+    durationMs?: number;
+    state: TranscriptState;
+    /** The line is part of an exchange that failed: it failed, or its answer did. */
+    exchangeFailed: boolean;
+    /** Its place in the lines, from 0: what a tie in time keeps. */
+    order: number;
+    /** The line itself. */
+    line: SceneTranscriptLine;
+};
+/** The span's or the entry's id a key belongs to: what an ask and its answer share. */
+export declare function exchangeOf(key: string): string;
+/** The exchanges that failed: a line failed, or its answer did. */
+export declare function failedExchangesOf(lines: readonly SceneTranscriptLine[]): Set<string>;
+/** Over what a line went, from who it reaches. */
+export declare function overOf(line: SceneTranscriptLine): TranscriptOver | undefined;
+/** The rows of a transcript, in the lines' order. */
+export declare function transcriptRows(lines: readonly SceneTranscriptLine[]): TranscriptRow[];
+/**
+ * Two rows by time: an open row after a closed one at the same time (it is
+ * still happening: last), a tie kept in the lines' order. What the table's
+ * Time column sorts by.
+ */
+export declare function compareByTime(a: TranscriptRow, b: TranscriptRow): number;
+/** The rows by time ({@link compareByTime}); descending reverses it. */
+export declare function byTime(rows: readonly TranscriptRow[], direction?: 'ASC' | 'DESC'): TranscriptRow[];
+/** A duration in words: `12 ms`, `1.2 s`, `1 min 3 s`. */
+export declare function durationText(ms: number | undefined): string;
+/** What a row's state says. */
+export declare const STATE_WORDS: Record<TranscriptState, string>;
+/** What a row's `over` says. */
+export declare const OVER_WORDS: Record<TranscriptOver, string>;
+/** The rows as a Markdown table: what *Copy as Markdown* copies. */
+export declare function transcriptMarkdown(rows: readonly TranscriptRow[]): string;
+/** What narrows the three views: by member, by kind, to what failed; what failed first. */
+export type TranscriptFilter = {
+    /** The members (and servers) a line is from or to; all when unsaid or empty. */
+    members?: readonly string[];
+    /** The kinds kept; all when unsaid or empty. */
+    kinds?: readonly SceneTranscriptKind[];
+    /** Only the exchanges that failed. */
+    failedOnly?: boolean;
+    /** The exchanges that failed first, each in its time order. */
+    failedFirst?: boolean;
+};
+/** The names a transcript speaks of: who is from or to, in first appearance. */
+export declare function namesOf(lines: readonly SceneTranscriptLine[]): string[];
+/** The lines the filter keeps, in order: the same lines for every view. */
+export declare function filterLines(lines: readonly SceneTranscriptLine[], filter?: TranscriptFilter): SceneTranscriptLine[];

package/lib/components/teams/transcript/transcriptRows.js

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The transcript as rows (SCENES S2-01): one row per line, with what the
+ * lines do not say in so many words — over which protocol an exchange went,
+ * how long a call or an ask took, in what state it is — and the filter the
+ * three views share: members, kinds, *failed only*, failed first.
+ *
+ * Pure: lines in, rows out, so that a test reads a recorded transcript and
+ * the page draws a live one the same way ({@link TranscriptTable}).
+ *
+ * @module components/teams/transcript/transcriptRows
+ */
+import { isToolHome, PERSON, timeText, } from '../sceneTranscriptRules.js';
+/** The span's or the entry's id a key belongs to: what an ask and its answer share. */
+export function exchangeOf(key) {
+    const at = key.lastIndexOf(':');
+    return at > 0 ? key.slice(0, at) : key;
+}
+/** Whether a line answers: words said back to the one who asked, or said to all at the end of a turn. */
+const isAnswer = (line) => line.kind === 'said';
+/** The answer of each exchange, by the exchange's id. */
+function answersOf(lines) {
+    const answers = new Map();
+    for (const line of lines) {
+        if (isAnswer(line)) {
+            answers.set(exchangeOf(line.key), line);
+        }
+    }
+    return answers;
+}
+/** The exchanges that failed: a line failed, or its answer did. */
+export function failedExchangesOf(lines) {
+    const failed = new Set();
+    for (const line of lines) {
+        if (line.failed) {
+            failed.add(exchangeOf(line.key));
+        }
+    }
+    return failed;
+}
+/** Over what a line went, from who it reaches. */
+export function overOf(line) {
+    if (line.kind === 'called') {
+        return isToolHome(line.to) ? 'tool' : 'mcp';
+    }
+    if (line.kind === 'asked') {
+        return line.from === PERSON ? undefined : 'a2a';
+    }
+    return line.to ? 'a2a' : undefined;
+}
+/** The rows of a transcript, in the lines' order. */
+export function transcriptRows(lines) {
+    const answers = answersOf(lines);
+    const failed = failedExchangesOf(lines);
+    return lines.map((line, order) => {
+        const exchange = exchangeOf(line.key);
+        const answer = line.kind === 'said' ? undefined : answers.get(exchange);
+        const durationMs = line.open
+            ? undefined
+            : answer
+                ? Math.max(0, answer.at - line.at)
+                : line.ended !== undefined
+                    ? Math.max(0, line.ended - line.at)
+                    : undefined;
+        return {
+            id: line.key,
+            at: line.at,
+            from: line.from,
+            ...(line.to ? { to: line.to } : {}),
+            ...(overOf(line) ? { over: overOf(line) } : {}),
+            kind: line.kind,
+            text: line.text,
+            ...(durationMs !== undefined ? { durationMs } : {}),
+            state: line.open ? 'open' : line.failed ? 'failed' : 'done',
+            exchangeFailed: failed.has(exchange),
+            order,
+            line,
+        };
+    });
+}
+/**
+ * Two rows by time: an open row after a closed one at the same time (it is
+ * still happening: last), a tie kept in the lines' order. What the table's
+ * Time column sorts by.
+ */
+export function compareByTime(a, b) {
+    return (a.at - b.at ||
+        Number(a.state === 'open') - Number(b.state === 'open') ||
+        a.order - b.order);
+}
+/** The rows by time ({@link compareByTime}); descending reverses it. */
+export function byTime(rows, direction = 'ASC') {
+    const ordered = [...rows].sort(compareByTime);
+    return direction === 'DESC' ? ordered.reverse() : ordered;
+}
+/** A duration in words: `12 ms`, `1.2 s`, `1 min 3 s`. */
+export function durationText(ms) {
+    if (ms === undefined) {
+        return '';
+    }
+    if (ms < 1000) {
+        return `${Math.round(ms)} ms`;
+    }
+    if (ms < 60_000) {
+        return `${(ms / 1000).toFixed(1).replace(/\.0$/, '')} s`;
+    }
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.round((ms % 60_000) / 1000);
+    return seconds ? `${minutes} min ${seconds} s` : `${minutes} min`;
+}
+/** What a row's state says. */
+export const STATE_WORDS = {
+    open: 'running',
+    failed: 'failed',
+    done: 'done',
+};
+/** What a row's `over` says. */
+export const OVER_WORDS = {
+    a2a: 'A2A',
+    mcp: 'MCP',
+    tool: 'tool',
+};
+/** A cell's text in a Markdown table: no bar, no line break. */
+const cell = (text) => text
+    .replace(/\|/g, '\\|')
+    .replace(/\s*\n\s*/g, ' ')
+    .trim();
+/** The rows as a Markdown table: what *Copy as Markdown* copies. */
+export function transcriptMarkdown(rows) {
+    const head = '| Time | From | To | Over | Kind | Text | Duration | State |';
+    const rule = '| --- | --- | --- | --- | --- | --- | --- | --- |';
+    const body = rows.map(row => [
+        timeText(row.at),
+        row.from,
+        row.to ?? '',
+        row.over ? OVER_WORDS[row.over] : '',
+        row.kind,
+        row.text,
+        durationText(row.durationMs),
+        STATE_WORDS[row.state],
+    ]
+        .map(cell)
+        .join(' | '));
+    return [head, rule, ...body.map(line => `| ${line} |`)].join('\n');
+}
+/** The names a transcript speaks of: who is from or to, in first appearance. */
+export function namesOf(lines) {
+    const names = [];
+    for (const line of lines) {
+        for (const name of [line.from, line.to]) {
+            if (name && !names.includes(name)) {
+                names.push(name);
+            }
+        }
+    }
+    return names;
+}
+/** The lines the filter keeps, in order: the same lines for every view. */
+export function filterLines(lines, filter = {}) {
+    const failed = failedExchangesOf(lines);
+    const members = filter.members?.length ? new Set(filter.members) : null;
+    const kinds = filter.kinds?.length ? new Set(filter.kinds) : null;
+    const kept = lines.filter(line => {
+        if (members &&
+            !members.has(line.from) &&
+            !(line.to && members.has(line.to))) {
+            return false;
+        }
+        if (kinds && !kinds.has(line.kind)) {
+            return false;
+        }
+        if (filter.failedOnly && !failed.has(exchangeOf(line.key))) {
+            return false;
+        }
+        return true;
+    });
+    if (!filter.failedFirst) {
+        return kept;
+    }
+    return [
+        ...kept.filter(line => failed.has(exchangeOf(line.key))),
+        ...kept.filter(line => !failed.has(exchangeOf(line.key))),
+    ];
+}