@datalayer/agent-runtimes 1.5.90 → 1.5.91

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

@@ -0,0 +1,13 @@
+/**
+ * What the three views share: the lines. In its own module so that the
+ * table and the diagram say the same shape without reading each other.
+ *
+ * @module components/teams/transcript/TranscriptViewsTypes
+ */
+import type { SceneTranscriptLine } from '../sceneTranscriptRules';
+/** The lines a view draws, in order: already filtered. */
+export type TranscriptRowsLines = {
+    lines: readonly SceneTranscriptLine[];
+};
+/** Which of the three views shows. */
+export type TranscriptViewChoice = 'lines' | 'table' | 'sequence';

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

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

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

@@ -0,0 +1,23 @@
+/**
+ * The message views of a scene (SCENES S2, S3): the transcript as rows and
+ * as a mermaid sequence diagram from the one list of lines, the three
+ * views under one switch, the drill-down, the selection the stage shares,
+ * the JSON export, and a recording played at its recorded pace
+ * (`useSceneRecording`, `RecordingLabel`). mermaid is loaded by `SequenceDiagram` when the
+ * view opens, never from here.
+ *
+ * @module components/teams/transcript
+ */
+export * from './transcriptRows';
+export * from './sequenceDiagramRules';
+export * from './selection';
+export * from './transcriptExport';
+export * from './transcriptDetailRules';
+export * from './TranscriptViewsTypes';
+export * from './TranscriptTable';
+export * from './SequenceDiagram';
+export * from './TranscriptDetail';
+export * from './TranscriptViews';
+export * from './recordingPlayback';
+export * from './useSceneRecording';
+export * from './RecordingLabel';

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The message views of a scene (SCENES S2, S3): the transcript as rows and
+ * as a mermaid sequence diagram from the one list of lines, the three
+ * views under one switch, the drill-down, the selection the stage shares,
+ * the JSON export, and a recording played at its recorded pace
+ * (`useSceneRecording`, `RecordingLabel`). mermaid is loaded by `SequenceDiagram` when the
+ * view opens, never from here.
+ *
+ * @module components/teams/transcript
+ */
+export * from './transcriptRows.js';
+export * from './sequenceDiagramRules.js';
+export * from './selection.js';
+export * from './transcriptExport.js';
+export * from './transcriptDetailRules.js';
+export * from './TranscriptViewsTypes.js';
+export * from './TranscriptTable.js';
+export * from './SequenceDiagram.js';
+export * from './TranscriptDetail.js';
+export * from './TranscriptViews.js';
+export * from './recordingPlayback.js';
+export * from './useSceneRecording.js';
+export * from './RecordingLabel.js';

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

@@ -0,0 +1,52 @@
+/**
+ * A recording played back: the transcript of a passing rehearsal
+ * (`<id>/recording.json`, `SceneRecordingFile`), its lines shown at the pace
+ * they were recorded, and the stage drawn as it was at each moment — which
+ * A2A links carried a message, which tool calls ran.
+ *
+ * Pure: a recording and a moment of it in, the lines said by then and the
+ * graph's `flows` and `calls` out. {@link useSceneRecording} drives it with
+ * a clock; a test reads it at any moment.
+ *
+ * @module components/teams/transcript/recordingPlayback
+ */
+import type { SceneRecordingFile } from '../../../types/scenes';
+import { type A2ATeamCall, type A2ATeamFlow } from '../a2aTeamFlow';
+import type { SceneTranscriptLine, SceneTranscriptMember } from '../sceneTranscriptRules';
+/** What a recording's label says: *Recording, taken 29 October 2026*. */
+export declare function recordingLabel(taken: string | undefined, locale?: string): string;
+/**
+ * The lines of a recording, as a stage draws them: every line, or one
+ * beat's (by its id, as `beats` says which lines it played). None for a
+ * beat the recording did not play.
+ */
+export declare function recordedLinesOf(recording: Pick<SceneRecordingFile, 'lines' | 'beats'>, beat?: string): SceneTranscriptLine[];
+/**
+ * When each line is shown, in milliseconds from the start of the playback:
+ * the recorded pace, divided by `speed`, with no pause longer than
+ * `maxGapMs` (a runtime starting between two beats is not worth watching).
+ */
+export declare function playbackOffsets(lines: readonly Pick<SceneTranscriptLine, 'at'>[], { speed, maxGapMs }?: {
+    speed?: number;
+    maxGapMs?: number;
+}): number[];
+/**
+ * The moment of the recording a playback offset stands for, in recorded
+ * milliseconds: the line shown last, plus the time since, at the same pace.
+ */
+export declare function recordedMomentAt(lines: readonly Pick<SceneTranscriptLine, 'at'>[], offsets: readonly number[], elapsed: number, speed?: number): number;
+/** What the stage shows at a moment of the recording: the links' flows and the calls running. */
+export type RecordedStage = {
+    /** Which way each peer's link carries a message, by the peer's id (`A2ATeamGraph`'s `flows`). */
+    flows: Record<string, A2ATeamFlow>;
+    /** The tool calls to the members' connections (`A2ATeamGraph`'s `calls`). */
+    calls: A2ATeamCall[];
+};
+/**
+ * The stage at a moment of the recording (`at`, recorded milliseconds), from
+ * the lines said by then: a link from the entry to a peer is `asking` while
+ * the peer's answer has not come, `answering` for {@link ANSWER_SHOWN_MS}
+ * after it; a call to a connection runs until it ended and shows its result
+ * coming back for {@link RESULT_SHOWN_MS}.
+ */
+export declare function recordedStageAt(lines: readonly SceneTranscriptLine[], at: number, members: readonly SceneTranscriptMember[], entry: string): RecordedStage;

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

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { ANSWER_SHOWN_MS, RESULT_SHOWN_MS, } from '../a2aTeamFlow.js';
+import { exchangeOf } from './transcriptRows.js';
+/** What a recording's label says: *Recording, taken 29 October 2026*. */
+export function recordingLabel(taken, locale = 'en-GB') {
+    const day = (taken ?? '').trim();
+    if (!day) {
+        return 'Recording';
+    }
+    const parsed = /^\d{4}-\d{2}-\d{2}$/.test(day)
+        ? new Date(`${day}T12:00:00Z`)
+        : new Date(day);
+    const shown = Number.isFinite(parsed.getTime())
+        ? parsed.toLocaleDateString(locale, {
+            day: 'numeric',
+            month: 'long',
+            year: 'numeric',
+            timeZone: 'UTC',
+        })
+        : day;
+    return `Recording, taken ${shown}`;
+}
+/**
+ * The lines of a recording, as a stage draws them: every line, or one
+ * beat's (by its id, as `beats` says which lines it played). None for a
+ * beat the recording did not play.
+ */
+export function recordedLinesOf(recording, beat) {
+    const lines = recording.lines.map(line => ({ ...line }));
+    if (!beat) {
+        return lines;
+    }
+    const found = recording.beats?.find(item => item.beat === beat);
+    return found ? lines.slice(found.first, found.first + found.count) : [];
+}
+/**
+ * When each line is shown, in milliseconds from the start of the playback:
+ * the recorded pace, divided by `speed`, with no pause longer than
+ * `maxGapMs` (a runtime starting between two beats is not worth watching).
+ */
+export function playbackOffsets(lines, { speed = 1, maxGapMs } = {}) {
+    const pace = speed > 0 ? speed : 1;
+    const offsets = [];
+    let offset = 0;
+    lines.forEach((line, index) => {
+        if (index > 0) {
+            let gap = Math.max(0, line.at - lines[index - 1].at) / pace;
+            if (maxGapMs !== undefined) {
+                gap = Math.min(gap, maxGapMs);
+            }
+            offset += gap;
+        }
+        offsets.push(Math.round(offset));
+    });
+    return offsets;
+}
+/**
+ * The moment of the recording a playback offset stands for, in recorded
+ * milliseconds: the line shown last, plus the time since, at the same pace.
+ */
+export function recordedMomentAt(lines, offsets, elapsed, speed = 1) {
+    if (lines.length === 0) {
+        return 0;
+    }
+    let last = 0;
+    for (let index = 0; index < offsets.length; index += 1) {
+        if (offsets[index] <= elapsed) {
+            last = index;
+        }
+    }
+    const since = Math.max(0, elapsed - offsets[last]) * (speed > 0 ? speed : 1);
+    const next = lines[last + 1]?.at;
+    const moment = lines[last].at + since;
+    return next === undefined ? moment : Math.min(moment, next);
+}
+function memberIdOf(name, members) {
+    if (!name) {
+        return undefined;
+    }
+    return (members.find(member => member.name === name)?.id ??
+        members.find(member => member.id === name)?.id);
+}
+/**
+ * The stage at a moment of the recording (`at`, recorded milliseconds), from
+ * the lines said by then: a link from the entry to a peer is `asking` while
+ * the peer's answer has not come, `answering` for {@link ANSWER_SHOWN_MS}
+ * after it; a call to a connection runs until it ended and shows its result
+ * coming back for {@link RESULT_SHOWN_MS}.
+ */
+export function recordedStageAt(lines, at, members, entry) {
+    const flows = {};
+    const calls = [];
+    const answers = new Map();
+    for (const line of lines) {
+        if (line.kind === 'said') {
+            answers.set(exchangeOf(line.key), line);
+        }
+    }
+    for (const line of lines) {
+        if (line.at > at) {
+            continue;
+        }
+        if (line.kind === 'asked') {
+            const asker = memberIdOf(line.from, members);
+            const asked = memberIdOf(line.to, members);
+            if (!asker || !asked || asker !== entry) {
+                continue;
+            }
+            const answer = answers.get(exchangeOf(line.key));
+            const answeredAt = answer?.at ?? line.ended;
+            if (answeredAt === undefined || at < answeredAt) {
+                flows[asked] = 'asking';
+            }
+            else if (at < answeredAt + ANSWER_SHOWN_MS) {
+                flows[asked] = 'answering';
+            }
+            else if (!flows[asked]) {
+                flows[asked] = 'still';
+            }
+            continue;
+        }
+        if (line.kind === 'called') {
+            const member = members.find(item => item.name === line.from || item.id === line.from);
+            const connection = member?.connections?.find(item => item.label === line.to || item.id === line.to);
+            if (!member || !connection) {
+                continue;
+            }
+            const ended = line.ended !== undefined && line.ended <= at ? line.ended : undefined;
+            if (ended !== undefined && at >= ended + RESULT_SHOWN_MS) {
+                continue;
+            }
+            calls.push({
+                member: member.id,
+                connection: connection.id,
+                tool: line.text,
+                id: line.key,
+                started: line.at,
+                ...(ended !== undefined ? { ended } : {}),
+            });
+        }
+    }
+    return { flows, calls };
+}

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

@@ -0,0 +1,59 @@
+/**
+ * The selection the transcript's views and the stage share (SCENES S3-02).
+ *
+ * A line selected in the Lines, Table or Sequence view — or a row, or an
+ * arrow — is one {@link TranscriptSelection}: the line's key, who it is from
+ * and to, its kind and time. The page holds it (`TranscriptViews`'s
+ * `selected`/`onSelect`) and hands the graph the edge it is on,
+ * {@link selectedEdgeOf}: the member ids and, for a call, the connection's
+ * node id, as `A2ATeamGraph` names its edges (`from->to` for an A2A link,
+ * `member->member/connection` for a connection's call edge).
+ *
+ * **The contract with the graph and its backdrops.** The graph takes
+ * `selected?: SelectedEdge | null` and draws that edge highlighted on every
+ * backdrop — by its `id`, or by its endpoints in either direction, since an
+ * answer travels the asker's edge back. A click on an edge gives the page the
+ * edge's latest exchange: the graph calls `onSelectEdge?(edge)` and the page
+ * answers with `latestLineOnEdge` to find the line to select.
+ *
+ * @module components/teams/transcript/selection
+ */
+import type { SceneTranscriptKind, SceneTranscriptLine, SceneTranscriptMember } from '../sceneTranscriptRules';
+/** A line selected, as the views and the stage share it. */
+export type TranscriptSelection = {
+    /** The line's key. */
+    key: string;
+    from: string;
+    to?: string;
+    kind: SceneTranscriptKind;
+    at: number;
+    failed?: boolean;
+};
+/** The edge of the graph a selection is on. */
+export type SelectedEdge = {
+    /** As the graph names it: `sales->accounting`, `accounting->accounting/odoo-accounting`. */
+    id: string;
+    /** The asker's or caller's member id. */
+    from: string;
+    /** The member asked (by id), or the connection's node id. */
+    to: string;
+    over: 'a2a' | 'mcp';
+    /** The selection it is for. */
+    key: string;
+};
+/** The selection a line is. */
+export declare function selectionOfLine(line: SceneTranscriptLine): TranscriptSelection;
+/** A connection's node id in the graph: the member's id, a slash, the connection's. */
+export declare const connectionNodeIdOf: (member: string, connection: string) => string;
+/**
+ * The edge a selection is on, or none: a line between two members is on
+ * their A2A link, oriented from the asker (an answer travels it back); a
+ * call is on the caller's edge to the connection whose label it reaches.
+ * A line the person speaks, or a call to a tool's home, is on no edge.
+ */
+export declare function selectedEdgeOf(selection: TranscriptSelection | null | undefined, members: readonly SceneTranscriptMember[]): SelectedEdge | undefined;
+/**
+ * The latest line on an edge: what a click on the edge selects. The edge's
+ * ends are member ids (or a connection's node id); the lines name members.
+ */
+export declare function latestLineOnEdge(edge: Pick<SelectedEdge, 'from' | 'to'>, lines: readonly SceneTranscriptLine[], members: readonly SceneTranscriptMember[]): SceneTranscriptLine | undefined;

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The selection a line is. */
+export function selectionOfLine(line) {
+    return {
+        key: line.key,
+        from: line.from,
+        ...(line.to ? { to: line.to } : {}),
+        kind: line.kind,
+        at: line.at,
+        ...(line.failed ? { failed: true } : {}),
+    };
+}
+/** A connection's node id in the graph: the member's id, a slash, the connection's. */
+export const connectionNodeIdOf = (member, connection) => `${member}/${connection}`;
+/** The member a name is: by name, then by id. */
+function memberOf(name, members) {
+    return name
+        ? (members.find(member => member.name === name) ??
+            members.find(member => member.id === name))
+        : undefined;
+}
+/**
+ * The edge a selection is on, or none: a line between two members is on
+ * their A2A link, oriented from the asker (an answer travels it back); a
+ * call is on the caller's edge to the connection whose label it reaches.
+ * A line the person speaks, or a call to a tool's home, is on no edge.
+ */
+export function selectedEdgeOf(selection, members) {
+    if (!selection || !selection.to) {
+        return undefined;
+    }
+    const from = memberOf(selection.from, members);
+    const to = memberOf(selection.to, members);
+    if (selection.kind === 'called') {
+        const connection = from?.connections?.find(one => one.label === selection.to || one.name === selection.to);
+        if (!from || !connection) {
+            return undefined;
+        }
+        const node = connectionNodeIdOf(from.id, connection.id);
+        return {
+            id: `${from.id}->${node}`,
+            from: from.id,
+            to: node,
+            over: 'mcp',
+            key: selection.key,
+        };
+    }
+    if (!from || !to) {
+        return undefined;
+    }
+    // An answer (`said`, with `to`) goes back along the ask's edge.
+    const [asker, asked] = selection.kind === 'said' ? [to, from] : [from, to];
+    return {
+        id: `${asker.id}->${asked.id}`,
+        from: asker.id,
+        to: asked.id,
+        over: 'a2a',
+        key: selection.key,
+    };
+}
+/**
+ * The latest line on an edge: what a click on the edge selects. The edge's
+ * ends are member ids (or a connection's node id); the lines name members.
+ */
+export function latestLineOnEdge(edge, lines, members) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        const on = selectedEdgeOf(selectionOfLine(line), members);
+        if (on &&
+            ((on.from === edge.from && on.to === edge.to) ||
+                (on.from === edge.to && on.to === edge.from))) {
+            return line;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * The transcript as a mermaid sequence diagram (SCENES S2-02): one
+ * participant per member and system in the cast's order (the person first,
+ * as an actor, when they speak), `->>` for an ask or a call, `-->>` for
+ * the answer, `activate`/`deactivate` around an exchange that is open or
+ * answered, `Note over` for words said to all, and a `rect` around an
+ * exchange that failed.
+ *
+ * Pure: lines in, source out — a golden file holds the source of a recorded
+ * transcript — and, beside it, which line each arrow and each note is, so
+ * that a click on the drawing finds its line ({@link SequenceDiagram}).
+ *
+ * @module components/teams/transcript/sequenceDiagramRules
+ */
+import { type SceneTranscriptLine } from '../sceneTranscriptRules';
+/** One of the cast, as the diagram stands them: a member, or a system a member reaches. */
+export type SequenceCastMember = {
+    name: string;
+    /** A system (a server reached over MCP), drawn after the members. */
+    system?: boolean;
+};
+/** The source, and which line each arrow and each note is, in drawing order. */
+export type SequenceDiagramPlan = {
+    source: string;
+    /** The key of the line each arrow (a message) carries, in the order drawn. */
+    arrows: string[];
+    /** The key of the line each note carries, in the order drawn. */
+    notes: string[];
+};
+/** Words on a diagram: one line, no statement end, no entity, clipped. */
+export declare function diagramText(text: string): string;
+/** The source and the map of its arrows and notes back to the lines. */
+export declare function sequenceDiagramPlan(lines: readonly SceneTranscriptLine[], cast?: readonly SequenceCastMember[]): SequenceDiagramPlan;
+/** The mermaid source of a transcript: what *Copy as mermaid* copies. */
+export declare function sequenceDiagramOf(lines: readonly SceneTranscriptLine[], cast?: readonly SequenceCastMember[]): string;

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

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The transcript as a mermaid sequence diagram (SCENES S2-02): one
+ * participant per member and system in the cast's order (the person first,
+ * as an actor, when they speak), `->>` for an ask or a call, `-->>` for
+ * the answer, `activate`/`deactivate` around an exchange that is open or
+ * answered, `Note over` for words said to all, and a `rect` around an
+ * exchange that failed.
+ *
+ * Pure: lines in, source out — a golden file holds the source of a recorded
+ * transcript — and, beside it, which line each arrow and each note is, so
+ * that a click on the drawing finds its line ({@link SequenceDiagram}).
+ *
+ * @module components/teams/transcript/sequenceDiagramRules
+ */
+import { PERSON } from '../sceneTranscriptRules.js';
+import { durationText, exchangeOf } from './transcriptRows.js';
+/** The most characters of a message: the rest is an ellipsis. */
+const MESSAGE_LENGTH = 72;
+/** The tint behind an exchange that failed: Primer's danger, faint, in light and dark. */
+const FAILED_RECT = 'rect rgba(248, 81, 73, 0.14)';
+/** Words on a diagram: one line, no statement end, no entity, clipped. */
+export function diagramText(text) {
+    const one = text.replace(/\s+/g, ' ').trim();
+    const clipped = one.length > MESSAGE_LENGTH ? `${one.slice(0, MESSAGE_LENGTH - 1)}…` : one;
+    return (clipped.replace(/[#;]/g, mark => (mark === '#' ? '#35;' : '#59;')) || ' ');
+}
+/** Each participant's alias: `p0`, `p1`…, in the order they stand. */
+function participantsOf(lines, cast) {
+    const names = [];
+    const spoken = new Set();
+    for (const line of lines) {
+        spoken.add(line.from);
+        if (line.to) {
+            spoken.add(line.to);
+        }
+    }
+    if (spoken.has(PERSON)) {
+        names.push(PERSON);
+    }
+    for (const member of [...cast].sort((a, b) => Number(Boolean(a.system)) - Number(Boolean(b.system)))) {
+        if (member.name !== PERSON && !names.includes(member.name)) {
+            names.push(member.name);
+        }
+    }
+    for (const line of lines) {
+        for (const name of [line.from, line.to]) {
+            if (name && !names.includes(name)) {
+                names.push(name);
+            }
+        }
+    }
+    const alias = new Map(names.map((name, index) => [name, `p${index}`]));
+    return { names, alias, actors: new Set([PERSON]) };
+}
+/** The source and the map of its arrows and notes back to the lines. */
+export function sequenceDiagramPlan(lines, cast = []) {
+    const { names, alias, actors } = participantsOf(lines, cast);
+    const id = (name) => alias.get(name) ?? name;
+    const out = ['sequenceDiagram'];
+    for (const name of names) {
+        out.push(`  ${actors.has(name) ? 'actor' : 'participant'} ${id(name)} as ${diagramText(name)}`);
+    }
+    const arrows = [];
+    const notes = [];
+    // The answers, by exchange: what an ask or a call waits for.
+    const answers = new Map();
+    for (const line of lines) {
+        if (line.kind === 'said') {
+            answers.set(exchangeOf(line.key), line);
+        }
+    }
+    // Who an exchange activated, until its answer deactivates them.
+    const active = new Map();
+    // The exchanges whose rect is open, closed by their failed answer.
+    const rects = new Set();
+    const failed = new Set();
+    for (const line of lines) {
+        if (line.failed) {
+            failed.add(exchangeOf(line.key));
+        }
+    }
+    const indent = () => (rects.size ? '    ' : '  ');
+    for (const line of lines) {
+        const exchange = exchangeOf(line.key);
+        const answer = answers.get(exchange);
+        if (line.kind === 'asked' || line.kind === 'called') {
+            if (failed.has(exchange) && answer && !rects.has(exchange)) {
+                out.push(`  ${FAILED_RECT}`);
+                rects.add(exchange);
+            }
+            const to = line.to ?? '';
+            out.push(`${indent()}${id(line.from)}->>${id(to)}: ${diagramText(line.text)}${line.open ? '…' : ''}`);
+            arrows.push(line.key);
+            if (line.open || answer || line.ended !== undefined) {
+                out.push(`${indent()}activate ${id(to)}`);
+                active.set(exchange, to);
+            }
+            if (line.kind === 'called' && !line.open && !answer) {
+                // A call's answer is its end: the tool answered, in so long, or failed.
+                const took = line.ended !== undefined && line.ended > line.at
+                    ? ` in ${durationText(line.ended - line.at)}`
+                    : '';
+                const opened = !rects.has(exchange) && line.failed;
+                if (opened) {
+                    out.push(`  ${FAILED_RECT}`);
+                    rects.add(exchange);
+                }
+                out.push(`${indent()}${id(to)}-->>${id(line.from)}: ${line.failed ? 'failed' : `answered${took}`}`);
+                arrows.push(line.key);
+                if (active.get(exchange) === to) {
+                    out.push(`${indent()}deactivate ${id(to)}`);
+                    active.delete(exchange);
+                }
+                if (rects.has(exchange)) {
+                    rects.delete(exchange);
+                    out.push('  end');
+                }
+            }
+            continue;
+        }
+        // Words said: back to who asked, or to all.
+        const asker = line.to ??
+            (lines.some(other => other.kind === 'asked' &&
+                other.from === PERSON &&
+                exchangeOf(other.key) === exchange)
+                ? PERSON
+                : undefined);
+        if (line.failed && !rects.has(exchange)) {
+            out.push(`  ${FAILED_RECT}`);
+            rects.add(exchange);
+        }
+        if (asker) {
+            out.push(`${indent()}${id(line.from)}-->>${id(asker)}: ${diagramText(line.text)}${line.failed ? ' (failed)' : ''}`);
+            arrows.push(line.key);
+        }
+        else {
+            out.push(`${indent()}Note over ${id(line.from)}: ${diagramText(line.text)}${line.failed ? ' (failed)' : ''}`);
+            notes.push(line.key);
+        }
+        if (active.get(exchange) === line.from) {
+            out.push(`${indent()}deactivate ${id(line.from)}`);
+            active.delete(exchange);
+        }
+        if (rects.has(exchange)) {
+            rects.delete(exchange);
+            out.push('  end');
+        }
+    }
+    return { source: `${out.join('\n')}\n`, arrows, notes };
+}
+/** The mermaid source of a transcript: what *Copy as mermaid* copies. */
+export function sequenceDiagramOf(lines, cast = []) {
+    return sequenceDiagramPlan(lines, cast).source;
+}