@kikedealba/recap 0.0.0-stage → 0.9.1

package/dist/live/detector.js

@@ -0,0 +1,498 @@
+import { spawn } from 'node:child_process';
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { isRecord, swiftLine } from "../core/json.js";
+import { isoNow } from "../core/dates.js";
+import { sleep, signalTree } from "../core/proc.js";
+import { prefix, replaceAll, suffix, trimmed } from "../core/text.js";
+import { RecapError, describeError } from "../errors.js";
+import { loadResource } from "../pipeline/resources.js";
+import { decodeSegment, orderSegments } from "../pipeline/transcript.js";
+import { boardEntries, makeAskId, removeBoard, writeBoard } from "./asking.js";
+import { isDuplicateQuestion } from "./dedupe.js";
+import { liveFiles, readLines } from "./files.js";
+import { renderLive } from "./merger.js";
+import { clockMilliseconds, resolveOrigin } from "./origin.js";
+import { decodeAnswer } from "./stream.js";
+function detectorError(text) {
+    return new RecapError('DETECTOR_OUTPUT', `Unexpected detector output: ${prefix(trimmed(text), 200)}`);
+}
+function findJson(text) {
+    const candidates = [
+        ['{', '}'],
+        ['[', ']'],
+    ];
+    const position = (char) => {
+        const index = text.indexOf(char);
+        return index === -1 ? text.length : index;
+    };
+    candidates.sort((left, right) => position(left[0]) - position(right[0]));
+    for (const [open, close] of candidates) {
+        const start = text.indexOf(open);
+        const end = text.lastIndexOf(close);
+        if (start === -1 || end === -1 || start >= end)
+            continue;
+        try {
+            return JSON.parse(text.slice(start, end + 1));
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+}
+function cleanQuestion(question) {
+    const text = trimmed(question);
+    return text.length === 0 || text.toLowerCase() === 'null' ? null : text;
+}
+function questionItem(object) {
+    const value = object['question'];
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'string')
+        throw new RecapError('DETECTOR_OUTPUT', `Unexpected detector question: ${prefix(JSON.stringify(value), 200)}`);
+    const text = cleanQuestion(value);
+    return text === null ? null : { text, atMs: clockMilliseconds(object['at']) };
+}
+function questionItems(list) {
+    const result = [];
+    for (const element of list) {
+        if (typeof element === 'string') {
+            const text = cleanQuestion(element);
+            if (text !== null)
+                result.push({ text, atMs: null });
+            continue;
+        }
+        if (!isRecord(element))
+            throw new RecapError('DETECTOR_OUTPUT', `Unexpected detector question: ${prefix(JSON.stringify(element) ?? String(element), 200)}`);
+        const item = questionItem(element);
+        if (item)
+            result.push(item);
+    }
+    return result;
+}
+export function parseDetectorResponse(text) {
+    const value = findJson(text);
+    if (value === undefined)
+        throw detectorError(text);
+    if (Array.isArray(value))
+        return questionItems(value);
+    if (!isRecord(value))
+        throw detectorError(text);
+    if ('questions' in value) {
+        const list = value['questions'];
+        if (list === null)
+            return [];
+        if (!Array.isArray(list))
+            throw new RecapError('DETECTOR_OUTPUT', `Unexpected detector questions: ${prefix(JSON.stringify(list), 200)}`);
+        return questionItems(list);
+    }
+    if (!('question' in value))
+        throw detectorError(text);
+    const item = questionItem(value);
+    return item ? [item] : [];
+}
+export class DetectionPacer {
+    minSeconds;
+    lastRun = null;
+    pending = true;
+    constructor(minSeconds) {
+        this.minSeconds = minSeconds;
+    }
+    grew() {
+        this.pending = true;
+    }
+    settle(remaining) {
+        if (remaining)
+            this.pending = true;
+    }
+    shouldRun(now) {
+        if (!this.pending)
+            return false;
+        if (this.lastRun !== null && (now - this.lastRun) / 1000 < this.minSeconds)
+            return false;
+        this.pending = false;
+        this.lastRun = now;
+        return true;
+    }
+}
+export const START_CURSOR = { detectedThroughMs: 0, examinedSegments: 0 };
+export function loadCursor(meetingDir) {
+    const text = readText(liveFiles.detectorState(meetingDir));
+    if (text === null)
+        return { ...START_CURSOR };
+    try {
+        const value = JSON.parse(text);
+        if (isRecord(value) && typeof value['detectedThroughMs'] === 'number' && typeof value['examinedSegments'] === 'number') {
+            return { detectedThroughMs: value['detectedThroughMs'], examinedSegments: value['examinedSegments'] };
+        }
+    }
+    catch {
+        return { ...START_CURSOR };
+    }
+    return { ...START_CURSOR };
+}
+export function saveCursor(meetingDir, cursor) {
+    writeAtomic(liveFiles.detectorState(meetingDir), swiftLine({ detectedThroughMs: cursor.detectedThroughMs, examinedSegments: cursor.examinedSegments }));
+}
+export const REVIEWED_SECONDS = 60;
+export function detectorBatch(segments, cursor) {
+    const examined = Math.min(Math.max(0, cursor.examinedSegments), segments.length);
+    const from = cursor.detectedThroughMs - REVIEWED_SECONDS * 1000;
+    const reviewed = orderSegments(segments.slice(0, examined).filter((segment) => segment.endMs >= from && trimmed(segment.text).length > 0));
+    const tail = segments.slice(examined);
+    const fresh = orderSegments(tail.filter((segment) => trimmed(segment.text).length > 0));
+    const through = tail.length > 0 ? Math.max(...tail.map((segment) => segment.endMs)) : cursor.detectedThroughMs;
+    return { reviewed, fresh, cursor: { detectedThroughMs: Math.max(cursor.detectedThroughMs, through), examinedSegments: segments.length } };
+}
+export function renderDetectPrompt(template, meeting, context, batch, known) {
+    const labelled = meeting.mode === 'remote';
+    const title = meeting.bitaEntry?.title ?? meeting.title;
+    const pages = context.pages.length === 0
+        ? '  (sin páginas registradas para este proyecto)'
+        : context.pages.map((page) => `  ${'  '.repeat(Math.max(0, page.depth))}- ${page.title}`).join('\n');
+    const speakers = labelled
+        ? 'Es una reunión remota: «Sala» es el micrófono de quien graba y «Remotos» es el audio de la llamada. Las preguntas que vienen de «Remotos» suelen ir dirigidas a quien graba y pesan más; una pregunta de «Sala» solo cuenta si es claramente una duda técnica abierta.'
+        : 'Es una reunión presencial con un solo micrófono («Sala»), sin separación por persona: juzga solo por el contenido de lo que se dice.';
+    const knownList = known.length === 0 ? '(ninguna)' : known.map((question) => `- ${question}`).join('\n');
+    const reviewed = batch.reviewed.length === 0 ? '(nada)' : renderLive(batch.reviewed, labelled);
+    let text = template;
+    text = replaceAll(text, '{{title}}', title);
+    text = replaceAll(text, '{{project}}', context.project ?? 'sin proyecto');
+    text = replaceAll(text, '{{pages}}', pages);
+    text = replaceAll(text, '{{speakers}}', speakers);
+    text = replaceAll(text, '{{known}}', knownList);
+    text = replaceAll(text, '{{reviewed}}', reviewed);
+    text = replaceAll(text, '{{transcript}}', renderLive(batch.fresh, labelled));
+    return text;
+}
+export function readTranscript(meetingDir) {
+    return readLines(liveFiles.transcript(meetingDir), decodeSegment);
+}
+export class QuestionDetector {
+    dir;
+    meeting;
+    dependencies;
+    pacer;
+    busy = null;
+    stopped = false;
+    detected = [];
+    cachedContext = null;
+    constructor(dir, meeting, minSeconds, dependencies) {
+        this.dir = dir;
+        this.meeting = meeting;
+        this.dependencies = dependencies;
+        this.pacer = new DetectionPacer(minSeconds);
+    }
+    get detectedQuestions() {
+        return [...this.detected];
+    }
+    now() {
+        return this.dependencies.now?.() ?? Date.now();
+    }
+    transcriptGrew() {
+        this.pacer.grew();
+    }
+    tick() {
+        if (this.stopped || this.busy !== null || !this.pacer.shouldRun(this.now()))
+            return false;
+        this.busy = (async () => {
+            const outcome = await this.runCycle();
+            const remaining = outcome.type === 'failed' ? true : this.hasUnexamined();
+            this.pacer.settle(remaining);
+        })().finally(() => {
+            this.busy = null;
+        });
+        return true;
+    }
+    async waitUntilIdle(timeoutSeconds) {
+        const current = this.busy;
+        if (!current)
+            return true;
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(false), timeoutSeconds * 1000);
+        });
+        try {
+            return await Promise.race([current.then(() => true), timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async stop(timeoutSeconds = 20) {
+        this.stopped = true;
+        if (!(await this.waitUntilIdle(timeoutSeconds)))
+            this.dependencies.log(`question detector did not stop within ${timeoutSeconds} s`);
+        await this.dependencies.cancelAsks?.();
+    }
+    hasUnexamined() {
+        return readTranscript(this.dir).length > loadCursor(this.dir).examinedSegments;
+    }
+    async runCycle() {
+        const outcome = await this.detect();
+        if (outcome.type === 'examined')
+            for (const question of outcome.duplicates)
+                this.dependencies.log(`auto ask: skipped duplicate «${question}»`);
+        if (outcome.type === 'failed')
+            this.dependencies.log(`auto ask: detection failed: ${outcome.message}`);
+        return outcome;
+    }
+    async detect() {
+        if (this.stopped)
+            return { type: 'idle' };
+        const segments = readTranscript(this.dir);
+        const batch = detectorBatch(segments, loadCursor(this.dir));
+        if (batch.fresh.length === 0) {
+            if (batch.cursor.examinedSegments !== loadCursor(this.dir).examinedSegments) {
+                try {
+                    saveCursor(this.dir, batch.cursor);
+                }
+                catch {
+                    return { type: 'idle' };
+                }
+            }
+            return { type: 'idle' };
+        }
+        const known = this.knownQuestions();
+        let found;
+        try {
+            const template = this.dependencies.template ? this.dependencies.template() : loadResource('detect-prompt.md');
+            const prompt = renderDetectPrompt(template, this.meeting, await this.context(), batch, known);
+            found = parseDetectorResponse(await this.dependencies.complete(prompt));
+        }
+        catch (error) {
+            return { type: 'failed', message: describeError(error) };
+        }
+        const queued = [];
+        const duplicates = [];
+        for (const detection of found) {
+            const question = detection.text;
+            if (isDuplicateQuestion(question, known)) {
+                duplicates.push(question);
+                continue;
+            }
+            if (this.stopped)
+                break;
+            this.detected.push(question);
+            known.push(question);
+            const origin = detection.atMs === null ? null : resolveOrigin(detection.atMs, [...batch.reviewed, ...batch.fresh], question);
+            this.dependencies.log(`auto ask: detected «${question}»${origin ? ` at ${origin.questionMs} ms (${origin.channel})` : ''}`);
+            this.dependencies.enqueue(question, origin);
+            queued.push(question);
+        }
+        if (this.stopped && queued.length < found.length - duplicates.length)
+            return { type: 'examined', queued, duplicates };
+        try {
+            saveCursor(this.dir, batch.cursor);
+        }
+        catch (error) {
+            return { type: 'failed', message: describeError(error) };
+        }
+        return { type: 'examined', queued, duplicates };
+    }
+    knownQuestions() {
+        const answered = readLines(liveFiles.answers(this.dir), decodeAnswer).map((answer) => answer.question);
+        const asking = boardEntries(this.dir).flatMap((state) => (state.question === null ? [] : [state.question]));
+        const seen = new Set();
+        return [...answered, ...asking, ...this.detected].filter((question) => {
+            if (trimmed(question).length === 0 || seen.has(question))
+                return false;
+            seen.add(question);
+            return true;
+        });
+    }
+    async context() {
+        if (this.cachedContext)
+            return this.cachedContext;
+        this.cachedContext = await this.dependencies.context();
+        return this.cachedContext;
+    }
+}
+export class AutoAskQueue {
+    dir;
+    concurrency;
+    pid;
+    now;
+    execute;
+    cancelRunning;
+    log;
+    waiting = [];
+    running = new Map();
+    stopped = false;
+    constructor(options) {
+        this.dir = options.dir;
+        this.concurrency = Math.max(1, options.concurrency);
+        this.pid = options.pid ?? process.pid;
+        this.now = options.now ?? isoNow;
+        this.execute = options.run;
+        this.cancelRunning = options.cancelRunning ?? (() => undefined);
+        this.log = options.log;
+    }
+    get runningCount() {
+        return this.running.size;
+    }
+    get waitingCount() {
+        return this.waiting.length;
+    }
+    enqueue(question, origin) {
+        if (this.stopped)
+            return null;
+        const job = { id: makeAskId(), question, origin, queuedAt: this.now() };
+        try {
+            writeBoard(this.dir, this.asking(job, 'queued'));
+        }
+        catch (error) {
+            this.log(`auto ask: cannot write the queued ask: ${describeError(error)}`);
+        }
+        this.waiting.push(job);
+        const ahead = this.waiting.length - 1;
+        this.log(`auto ask: queued «${question}» as ${job.id}${ahead > 0 ? ` (${ahead} waiting ahead)` : ''}`);
+        this.pump();
+        return job;
+    }
+    async waitUntilIdle(timeoutSeconds) {
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        while (this.running.size > 0 || (this.waiting.length > 0 && !this.stopped)) {
+            if (Date.now() > deadline)
+                return false;
+            const pending = [...this.running.values()];
+            if (pending.length === 0) {
+                await sleep(10);
+                continue;
+            }
+            let timer;
+            await Promise.race([
+                Promise.allSettled(pending),
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, Math.max(0, deadline - Date.now()));
+                }),
+            ]);
+            clearTimeout(timer);
+        }
+        return true;
+    }
+    async cancelAll(timeoutSeconds = 10) {
+        this.stopped = true;
+        const dropped = this.waiting;
+        this.waiting = [];
+        for (const job of dropped) {
+            removeBoard(this.dir, job.id);
+            this.log(`auto ask: dropped «${job.question}» because the worker stopped`);
+        }
+        this.cancelRunning();
+        if (!(await this.waitUntilIdle(timeoutSeconds)))
+            this.log(`auto asks did not stop within ${timeoutSeconds} s`);
+    }
+    pump() {
+        while (!this.stopped && this.running.size < this.concurrency && this.waiting.length > 0) {
+            const job = this.waiting.shift();
+            if (!job)
+                break;
+            try {
+                writeBoard(this.dir, this.asking(job, 'running'));
+            }
+            catch {
+                this.log(`auto ask: cannot mark ${job.id} as running`);
+            }
+            this.running.set(job.id, this.run(job));
+        }
+    }
+    async run(job) {
+        const started = Date.now();
+        this.log(`auto ask: started «${job.question}» (${job.id})`);
+        try {
+            await this.execute(job);
+            this.log(`auto ask: answered «${job.question}» in ${((Date.now() - started) / 1000).toFixed(1)} s`);
+        }
+        catch (error) {
+            this.log(`auto ask: failed «${job.question}»: ${describeError(error)}`);
+        }
+        removeBoard(this.dir, job.id);
+        this.running.delete(job.id);
+        this.pump();
+    }
+    asking(job, phase) {
+        return {
+            id: job.id,
+            question: job.question,
+            startedAt: phase === 'queued' ? job.queuedAt : this.now(),
+            auto: true,
+            questionMs: job.origin?.questionMs,
+            channel: job.origin?.channel,
+            state: phase,
+            pid: this.pid,
+        };
+    }
+}
+export function autoAskArguments(dir, question, origin = null, askId) {
+    const args = ['ask', '--dir', dir, '--question', question, '--auto', '--json'];
+    if (origin)
+        args.push('--question-ms', String(origin.questionMs), '--channel', origin.channel);
+    if (askId)
+        args.push('--ask-id', askId);
+    return args;
+}
+export function envelopeFailure(output) {
+    for (const line of output.split('\n').reverse()) {
+        try {
+            const object = JSON.parse(line);
+            if (isRecord(object) && isRecord(object['error']) && typeof object['error']['code'] === 'string') {
+                const error = object['error'];
+                return new RecapError(error['code'], typeof error['message'] === 'string' ? error['message'] : error['code']);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export class AutoAskProcess {
+    dir;
+    command;
+    processes = new Map();
+    constructor(dir, command) {
+        this.dir = dir;
+        this.command = command;
+    }
+    run(job) {
+        const [executable, ...prefixArgs] = this.command;
+        return new Promise((resolve, reject) => {
+            const child = spawn(executable ?? process.execPath, [...prefixArgs, ...autoAskArguments(this.dir, job.question, job.origin, job.id)], {
+                cwd: this.dir,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
+                windowsHide: true,
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.setEncoding('utf8').on('data', (chunk) => (stdout += chunk));
+            child.stderr.setEncoding('utf8').on('data', (chunk) => (stderr += chunk));
+            if (child.pid !== undefined)
+                this.processes.set(job.id, child.pid);
+            child.once('error', (error) => {
+                this.processes.delete(job.id);
+                reject(new RecapError('ASK_FAILED', error.message));
+            });
+            child.once('close', (code, signal) => {
+                this.processes.delete(job.id);
+                if (signal !== null || code === 129 || code === 130 || code === 143) {
+                    reject(new RecapError('ASK_INTERRUPTED', `The auto ask was stopped (status ${code ?? signal})`));
+                    return;
+                }
+                if (code !== 0) {
+                    const failure = envelopeFailure(stdout);
+                    if (failure)
+                        return reject(failure);
+                    const detail = trimmed(stderr);
+                    return reject(new RecapError('ASK_FAILED', detail.length === 0 ? `recap ask exited with status ${code}` : suffix(detail, 400)));
+                }
+                resolve();
+            });
+        });
+    }
+    cancel() {
+        for (const pid of this.processes.values())
+            signalTree(pid, 'SIGTERM');
+    }
+}

package/dist/live/files.js

@@ -0,0 +1,48 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { readText } from "../core/fsutil.js";
+import { swiftLine } from "../core/json.js";
+export const LIVE_DIR = 'live';
+export const CHUNKS_DIR = 'chunks';
+export const liveFiles = {
+    dir: (meetingDir) => path.join(meetingDir, LIVE_DIR),
+    chunks: (meetingDir) => path.join(meetingDir, LIVE_DIR, CHUNKS_DIR),
+    chunkIndex: (meetingDir) => path.join(meetingDir, LIVE_DIR, CHUNKS_DIR, 'index.jsonl'),
+    transcript: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'transcript.jsonl'),
+    answers: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'answers.jsonl'),
+    workerLock: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'worker.pid'),
+    workerState: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'worker-state.json'),
+    detectorState: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'detector-state.json'),
+    asking: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'asking.json'),
+    askingDir: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'asking'),
+    workerLog: (meetingDir) => path.join(meetingDir, LIVE_DIR, 'worker.log'),
+};
+export function jsonLine(value) {
+    return swiftLine(value);
+}
+export function appendLines(values, file) {
+    if (values.length === 0)
+        return;
+    mkdirSync(path.dirname(file), { recursive: true });
+    appendFileSync(file, values.map((value) => `${jsonLine(value)}\n`).join(''));
+}
+export function parseLines(text, decode) {
+    const result = [];
+    for (const line of text.split('\n')) {
+        if (line.trim().length === 0)
+            continue;
+        try {
+            const decoded = decode(JSON.parse(line));
+            if (decoded !== null)
+                result.push(decoded);
+        }
+        catch {
+            continue;
+        }
+    }
+    return result;
+}
+export function readLines(file, decode) {
+    const text = readText(file);
+    return text === null ? [] : parseLines(text, decode);
+}

package/dist/live/merger.js

@@ -0,0 +1,100 @@
+import { readText } from "../core/fsutil.js";
+import { setsEqual, tokens } from "../core/text.js";
+import { clock } from "../core/dates.js";
+import { ECHO_WINDOW_MS, decodeSegment, isEcho, orderSegments, paragraphs, speakerLabel } from "../pipeline/transcript.js";
+import { liveFiles, readLines } from "./files.js";
+import path from 'node:path';
+export const SYSTEM_MEMORY_MS = 60_000;
+export const REPEAT_WINDOW_MS = 30_000;
+export class LiveMerger {
+    hasSystem;
+    holdSeconds;
+    systemCoveredMs = 0;
+    recentSystem = [];
+    pendingMic = [];
+    lastText = {};
+    constructor(hasSystem, holdSeconds) {
+        this.hasSystem = hasSystem;
+        this.holdSeconds = holdSeconds;
+    }
+    get pendingCount() {
+        return this.pendingMic.length;
+    }
+    add(segments, channel, coveredUntilMs, now) {
+        const fresh = segments.filter((segment) => !this.isRepeat(segment));
+        if (channel === 'system') {
+            this.recentSystem.push(...fresh);
+            this.systemCoveredMs = Math.max(this.systemCoveredMs, coveredUntilMs);
+            const horizon = this.systemCoveredMs - SYSTEM_MEMORY_MS;
+            this.recentSystem = this.recentSystem.filter((segment) => segment.endMs >= horizon);
+            return orderSegments([...fresh, ...this.release(now, false)]);
+        }
+        if (!this.hasSystem)
+            return orderSegments(fresh);
+        this.pendingMic.push(...fresh.map((segment) => ({ segment, addedAt: now })));
+        return orderSegments(this.release(now, false));
+    }
+    advance(channel, toMs, now) {
+        if (channel === 'system')
+            this.systemCoveredMs = Math.max(this.systemCoveredMs, toMs);
+        return orderSegments(this.release(now, false));
+    }
+    release(now, force) {
+        const ready = [];
+        const waiting = [];
+        for (const item of this.pendingMic) {
+            const covered = item.segment.endMs + ECHO_WINDOW_MS <= this.systemCoveredMs;
+            const expired = (now - item.addedAt) / 1000 >= this.holdSeconds;
+            if (force || covered || expired) {
+                if (!this.recentSystem.some((system) => isEcho(item.segment, system)))
+                    ready.push(item.segment);
+            }
+            else {
+                waiting.push(item);
+            }
+        }
+        this.pendingMic = waiting;
+        return orderSegments(ready);
+    }
+    isRepeat(segment) {
+        const previous = this.lastText[segment.channel];
+        this.lastText[segment.channel] = segment;
+        if (!previous)
+            return false;
+        const current = tokens(segment.text);
+        return segment.startMs - previous.endMs <= REPEAT_WINDOW_MS && current.size > 0 && setsEqual(tokens(previous.text), current);
+    }
+}
+export function loadLiveTranscript(meetingDir) {
+    const live = readLines(liveFiles.transcript(meetingDir), decodeSegment);
+    if (live.length > 0)
+        return orderSegments(live);
+    const text = readText(path.join(meetingDir, 'transcript.json'));
+    if (text === null)
+        return [];
+    try {
+        const value = JSON.parse(text);
+        if (!Array.isArray(value))
+            return [];
+        const segments = value.map(decodeSegment);
+        if (segments.some((segment) => segment === null))
+            return [];
+        return orderSegments(segments);
+    }
+    catch {
+        return [];
+    }
+}
+export function transcriptWindow(segments, seconds) {
+    if (segments.length === 0)
+        return [];
+    const latest = Math.max(...segments.map((segment) => segment.endMs));
+    const from = latest - Math.max(1, seconds) * 1000;
+    return segments.filter((segment) => segment.endMs >= from);
+}
+export function renderLive(segments, labelled) {
+    const grouped = paragraphs(segments);
+    if (grouped.length === 0)
+        return '_Todavía no hay transcripción._';
+    return grouped.map((paragraph) => `[${clock(paragraph.startMs)}]${labelled ? ` ${speakerLabel(paragraph.channel)}:` : ''} ${paragraph.text}`).join('\n');
+}