allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/thread.js

@@ -0,0 +1,537 @@
+/**
+ * The Slack provider (`ChatProvider` of the chat seam) and one Slack thread as its session uses
+ * it (`ThreadChat`), composed from what the provider already has: a `ReplySink` per reply, the
+ * `StatusReaction` on the thread's root, the `ThreadStatus` line under its last message, and the
+ * request messages of `requests.ts`.
+ *
+ * What the thread adds to those parts is their wiring: every pass of a reply that wrote, and every
+ * notice, tells the status line (Slack clears a thread's status when the app replies); the
+ * seam's four statuses are the four reactions; an answered question is rewritten on the budget
+ * every reply draws from; and a failed post or rewrite crosses the seam as a `ChatError` named
+ * by Slack's code.
+ */
+import { monotonicClock, systemClock } from "../../clock.js";
+import { Cancelled, named, texts, } from "../../core/port.js";
+import { getLogger } from "../../log.js";
+import { ChatError, } from "../seam.js";
+import { buildApp } from "./app/app.js";
+import { threadKey } from "./app/order.js";
+import { SlackChannel } from "./channel.js";
+import { channelLookup, threadLookup } from "./channels.js";
+import { holdBlocks } from "./hold.js";
+import { crossing, deliver, deliverNotice } from "./notice.js";
+import { endReply } from "./repair.js";
+import { contextBlock, noticeText, split } from "./reply/blocks.js";
+import { deleteRequest, describe } from "./reply/errors.js";
+import { markdownEscape, mrkdwnEscape } from "./reply/escape.js";
+import { ThreadPlaces } from "./reply/places.js";
+import { ReplySink } from "./reply/sinks.js";
+import { REACTIONS, StatusReaction, ThreadStatus } from "./reply/status.js";
+import { answeredBlocks, approvalBlocks, questionBlocks } from "./requests.js";
+import { setupBlocks } from "./setup.js";
+export const logger = getLogger("allaboard.chat.slack.thread");
+/** Slack draws every part of the chat seam. */
+const CAPABILITIES = {
+    nativeStreaming: true,
+    reactions: true,
+    activityLine: true,
+    fileUpload: true,
+};
+/** The Slack provider: one `SlackThread` per thread, one `SlackChannel` per channel. */
+export class SlackChat {
+    name = "Slack";
+    capabilities = CAPABILITIES;
+    /**
+     * The bot of the workspace, and the app-level token of the connection when there is one: the
+     * two things a copied `.env` can leave the same, each of which makes Socket Mode spread events
+     * across the connections of two daemons.
+     */
+    identities;
+    /** Present when the provider holds the Home tab (`SlackApp.home`). */
+    index;
+    options;
+    stopping = new AbortController();
+    built = null;
+    /**
+     * Where each thread's messages sit, by thread, while a thread object that opened a reply in it
+     * is open (`users`), and after that while a reply of it is registered.
+     */
+    places = new Map();
+    named = null;
+    constructor(options) {
+        this.options = options;
+        this.identities = [
+            `${options.identity.teamId}:${options.identity.botUserId}`,
+            ...(options.app !== undefined ? [options.app.appKey] : []),
+        ];
+        const home = options.app?.home;
+        if (home !== undefined)
+            this.index = { refresh: (changed) => home.request(changed) };
+    }
+    /**
+     * The `chat.update` budget every reply in the process draws from, so an edit made outside a
+     * reply (a handler's own) can share it.
+     */
+    get limiter() {
+        return this.options.limiter;
+    }
+    /**
+     * Aborts when the daemon stops. A listener still in flight then does nothing at its next
+     * step: the sessions are closed and the lock is released.
+     */
+    get stopped() {
+        return this.stopping.signal;
+    }
+    /** Tells every listener, and every call of the chat, that the daemon is stopping. */
+    halt() {
+        this.stopping.abort();
+    }
+    /** The names the texts take, the agent's and this chat's, made when first asked for. */
+    names() {
+        this.named ??= texts.namesOf(this.options.agent(), this);
+        return this.named;
+    }
+    /** What the setup posted for `requestId` said to draw, or undefined when it is no longer kept. */
+    drawnSetup(requestId) {
+        return drawnSetups.get(this.options)?.get(requestId);
+    }
+    thread(ref) {
+        return new SlackThread(ref.channel, ref.thread, this.options, () => this.names(), this.stopped, this.leaseOf(ref.channel, ref.thread));
+    }
+    /**
+     * The owner wrote a message at `ts` in a thread. Called by the listener for every owner
+     * message, before anything else of it is decided: a message the core later refuses still sits
+     * below the replies above it.
+     */
+    ownerPosted(channel, thread, ts) {
+        this.places.get(threadKey(channel, thread))?.places.ownerPosted(ts);
+    }
+    /**
+     * The thread's places: one object for every `SlackThread` of it, so that the replies of the
+     * thread's successive sessions see each other. A thread object takes it at its first reply and
+     * gives it back at its close (`ThreadLease`). It lives while one is open: a reply let go of
+     * by an owner message must still be found by the next one. After the last give-back it lives
+     * while a reply is registered with it.
+     */
+    leaseOf(channel, thread) {
+        const key = threadKey(channel, thread);
+        return {
+            peek: () => this.places.get(key)?.places,
+            take: () => {
+                const known = this.places.get(key);
+                if (known !== undefined) {
+                    known.users += 1;
+                    return known.places;
+                }
+                const made = new ThreadPlaces(() => {
+                    const entry = this.places.get(key);
+                    if (entry?.places === made && entry.users === 0)
+                        this.places.delete(key);
+                });
+                this.places.set(key, { places: made, users: 1 });
+                return made;
+            },
+            give: () => {
+                const entry = this.places.get(key);
+                if (entry === undefined)
+                    return;
+                entry.users -= 1;
+                if (entry.users === 0 && !entry.places.held)
+                    this.places.delete(key);
+            },
+        };
+    }
+    /**
+     * The thread as a handler answers in it. A post of the app's clears the status line of the
+     * session that lives there, not of this object, which only posts: `written` sets that line
+     * again.
+     */
+    answering(ref, written) {
+        return new SlackThread(ref.channel, ref.thread, this.options, () => this.names(), this.stopped, this.leaseOf(ref.channel, ref.thread), written);
+    }
+    channel(channel) {
+        const { slack, identity, limiter, clock } = this.options;
+        return new SlackChannel(channel, {
+            slack,
+            ownerUserId: identity.ownerUserId,
+            limiter,
+            clock: clock ?? systemClock,
+            stopped: this.stopped,
+            names: () => this.names(),
+        });
+    }
+    escape(text, markup) {
+        return markup === "notice" ? mrkdwnEscape(text) : markdownEscape(text);
+    }
+    // Slack's channel syntax in a notice. Whether a markdown block renders it was not confirmed
+    // (the block's reference names neither mentions nor angle brackets), so `reference` gets the same.
+    channelName(channel, _markup) {
+        return `<#${channel}>`;
+    }
+    openedAt(ref) {
+        // A Slack ts is the post time in epoch seconds.
+        const seconds = ref.thread.trim() === "" ? Number.NaN : Number(ref.thread);
+        return Number.isNaN(seconds) ? null : seconds;
+    }
+    channelState(channel) {
+        return channelLookup(this.options.slack)(channel);
+    }
+    threadState(ref) {
+        return threadLookup(this.options.slack)(ref);
+    }
+    async openFile(ref, folder, target) {
+        if (this.built === null)
+            throw new Error("the Slack app is not started");
+        await this.built.openFile(ref.channel, ref.thread, folder, target);
+    }
+    async start(inbound) {
+        const { app, identity, steady } = this.options;
+        if (app === undefined)
+            throw new Error("this Slack provider was built with no app to open");
+        const core = app.core();
+        this.built = buildApp({
+            chat: this,
+            slack: this.options.slack,
+            config: app.config,
+            identity,
+            sessions: core.sessions,
+            approvals: core.approvals,
+            holds: core.holds,
+            names: this.names(),
+            inbound,
+            guard: app.guard,
+            state: core.state,
+            uploads: app.uploads,
+            home: app.home,
+            receiver: app.receiver,
+            ...(steady !== undefined && { clock: steady }),
+            ...(app.fetch !== undefined && { fetch: app.fetch }),
+            ...(app.now !== undefined && { now: app.now }),
+            ...(app.listings !== undefined && { listings: app.listings }),
+        });
+        await this.built.app.start();
+        logger.info(`connected to Slack workspace ${identity.teamId}`);
+    }
+    async stop() {
+        const built = this.built;
+        try {
+            await built?.app.stop();
+        }
+        finally {
+            // Even when the connection would not close: what listens must stop all the same.
+            this.halt();
+            // The timers of clips still waiting for a transcript would keep the process alive.
+            built?.close();
+        }
+    }
+    async close() {
+        await this.options.app?.home.close();
+    }
+}
+// The requests a provider withdrew lately, by channel and message, per provider (the options it
+// was built over). A rewrite that waited for the budget while its message was withdrawn writes
+// nothing.
+const WITHDRAWN_KEPT = 64;
+const withdrawn = new WeakMap();
+// What the setups posted lately said to draw, by request id, per provider. A click that only
+// redraws a setup (a model picked) draws the message again from this, since the hold it finds
+// keeps the model list alone.
+const SETUPS_KEPT = 64;
+const drawnSetups = new WeakMap();
+export class SlackThread {
+    channel;
+    threadTs;
+    options;
+    names;
+    slack;
+    clock;
+    // One reaction on the session's root message, which `threadTs` always is (a top-level owner
+    // message, or the root of a `!resume` thread, the owner's own message).
+    reaction;
+    /** Issues #83 and #95: Slack's status line at the bottom of the thread. */
+    line;
+    stopped;
+    lease;
+    /** The places of this thread, once a reply was opened in it and until the close. */
+    places = null;
+    onWritten;
+    /** The replies this object opened, with the places each is registered in. */
+    opened = [];
+    /**
+     * `written` stands for this object's own status line where something else holds it: the
+     * handlers answer through a thread of their own, and the session's line is the one a post
+     * clears.
+     */
+    constructor(channelId, threadTs, options, names, stopped, lease, written) {
+        this.channel = channelId;
+        this.threadTs = threadTs;
+        this.options = options;
+        this.names = names;
+        this.stopped = stopped;
+        this.lease = lease;
+        this.slack = options.slack;
+        this.clock = options.clock ?? systemClock;
+        this.reaction = new StatusReaction(this.slack, { channel: channelId, rootTs: threadTs });
+        this.line = new ThreadStatus(this.slack, {
+            channel: channelId,
+            threadTs,
+            clock: options.steady ?? options.clock ?? monotonicClock,
+        });
+        this.onWritten = written ?? (() => this.line.wrote());
+    }
+    openReply(onOpenMessage) {
+        const { identity } = this.options;
+        this.places ??= this.lease.take();
+        const places = this.places;
+        const reply = new ReplySink(this.options.replies, {
+            channel: this.channel,
+            threadTs: this.threadTs,
+            teamId: identity.teamId,
+            userId: identity.ownerUserId,
+            botUserId: identity.botUserId,
+            limiter: this.options.limiter,
+            clock: this.clock,
+            ...(this.options.steady !== undefined && { steady: this.options.steady }),
+            onOpenReply: onOpenMessage,
+            onWrite: () => this.line.wrote(),
+            places,
+            ...(this.options.debounceSeconds !== undefined && {
+                debounceSeconds: this.options.debounceSeconds,
+            }),
+            ...(this.options.finalRetrySeconds !== undefined && {
+                finalRetrySeconds: this.options.finalRetrySeconds,
+            }),
+        });
+        // A reply the places let go of needs no letting go at close, and must not stay reachable.
+        this.opened.splice(0, this.opened.length, ...this.opened.filter(([held, old]) => held.holds(old)));
+        this.opened.push([places, reply]);
+        return reply;
+    }
+    showRunning(list) {
+        // No reply was opened yet: there is nothing for the list to sit under.
+        this.places?.showRunning(list);
+    }
+    showStatus(status, signal) {
+        return this.reaction.show(REACTIONS[status], signal);
+    }
+    clearStatus() {
+        return this.reaction.clear();
+    }
+    settleStatus() {
+        return this.reaction.settle();
+    }
+    showActivity(text, afterName) {
+        this.line.show(text, afterName);
+    }
+    get activityRefused() {
+        return ThreadStatus.refused();
+    }
+    written() {
+        this.onWritten();
+    }
+    /**
+     * A message of the app's own posted in the thread outside a reply: the places learn where it
+     * sits, so that no reply posts its closing message below it later. Null for an ephemeral one.
+     */
+    postedOwn(ts) {
+        if (typeof ts === "string" && ts !== "")
+            (this.places ?? this.lease.peek())?.posted(ts);
+    }
+    async notice(text) {
+        // mrkdwn reads `&`, `<` and `>` as markup, and a notice can quote the owner's own message.
+        const shown = mrkdwnEscape(text);
+        try {
+            const posted = await this.slack.chat.postMessage({
+                channel: this.channel,
+                thread_ts: this.threadTs,
+                text: shown,
+                blocks: [contextBlock(noticeText(shown))],
+                unfurl_links: false,
+                unfurl_media: false,
+            });
+            this.postedOwn(posted.ts);
+            this.line.wrote(); // a post of the app's clears the thread's status
+        }
+        catch (error) {
+            logger.error(`could not post in ${this.channel}/${this.threadTs}: ${describe(error)}`);
+        }
+    }
+    async ask(requestId, request, title) {
+        let blocks;
+        switch (request.type) {
+            case "question":
+                blocks = questionBlocks(requestId, request.questions, this.names());
+                break;
+            case "permission":
+                blocks = approvalBlocks(requestId, request, this.names());
+                break;
+            case "hold":
+                blocks = holdBlocks(requestId, request.link);
+                break;
+            case "setup":
+                this.noteSetup(requestId, request);
+                blocks = setupBlocks(requestId, request, request.selection);
+                break;
+        }
+        let ts;
+        try {
+            const posted = await this.slack.chat.postMessage({
+                channel: this.channel,
+                thread_ts: this.threadTs,
+                text: title,
+                // Built to Block Kit's reference by the modules that make them: opaque to the library's types.
+                blocks: blocks,
+                unfurl_links: false,
+                unfurl_media: false,
+            });
+            ts = posted.ts;
+        }
+        catch (error) {
+            // A wait that was cancelled is no refusal of the chat: it crosses as it is.
+            if (error instanceof Cancelled)
+                throw error;
+            throw new ChatError(describe(error), { cause: error });
+        }
+        // The message is the only handle on its buttons: one Slack did not name cannot be removed.
+        if (typeof ts !== "string" || ts === "")
+            throw new ChatError("no_ts");
+        this.postedOwn(ts);
+        return ts;
+    }
+    async withdraw(request) {
+        // (sync) Noted before the first await: a rewrite waiting for the budget sees it.
+        this.noteWithdrawn(request);
+        return await deleteRequest(this.slack, { channel: this.channel, ts: request });
+    }
+    async keepAnswers(request, questions, answers) {
+        try {
+            // One more chat.update against the app's budget, which every reply draws from.
+            await this.options.limiter.acquire();
+            await this.slack.chat.update({
+                channel: this.channel,
+                ts: request,
+                text: named(texts.ANSWERED, this.names()),
+                blocks: answeredBlocks(questions, answers, this.names()),
+            });
+        }
+        catch (error) {
+            throw new ChatError(describe(error), { cause: error });
+        }
+    }
+    rewrite(message, text) {
+        return crossing(async () => {
+            await this.options.limiter.acquire();
+            // The wait can outlast the message (withdrawn by a `!stop`) and the daemon: nothing is
+            // left to edit then, and the edit would only be refused.
+            if (this.stopped.aborted || this.wasWithdrawn(message))
+                return;
+            await this.slack.chat.update({
+                channel: this.channel,
+                ts: message,
+                text,
+                blocks: [contextBlock(noticeText(text))],
+            });
+        });
+    }
+    noteSetup(requestId, request) {
+        const kept = drawnSetups.get(this.options) ?? new Map();
+        drawnSetups.set(this.options, kept);
+        const { models, efforts, bypassOffered } = request;
+        kept.set(requestId, { models, efforts, bypassOffered });
+        // Only a setup that is waiting right now can be redrawn: the oldest go.
+        for (const old of kept.keys()) {
+            if (kept.size <= SETUPS_KEPT)
+                break;
+            kept.delete(old);
+        }
+    }
+    noteWithdrawn(message) {
+        const kept = withdrawn.get(this.options) ?? new Set();
+        withdrawn.set(this.options, kept);
+        kept.add(`${this.channel}/${message}`);
+        // Only a rewrite that is waiting right now cares: the oldest go.
+        for (const old of kept) {
+            if (kept.size <= WITHDRAWN_KEPT)
+                break;
+            kept.delete(old);
+        }
+    }
+    wasWithdrawn(message) {
+        return withdrawn.get(this.options)?.has(`${this.channel}/${message}`) ?? false;
+    }
+    async tell(text, options = {}) {
+        if (this.stopped.aborted)
+            return;
+        try {
+            this.postedOwn(await deliverNotice(this.slack, this.options.identity.ownerUserId, this.place, text, {
+                ephemeral: !options.stays,
+            }));
+            // Slack clears a thread's status line when the app replies: the session's is set
+            // again, so `Working…` does not go for a minute after the answer to a word.
+            this.written();
+        }
+        catch (error) {
+            logger.warning(`could not reach the owner in ${this.channel}: ${describe(error)}`);
+        }
+    }
+    async say(markdown, options = {}) {
+        for (const chunk of split(markdown)) {
+            if (this.stopped.aborted)
+                return;
+            this.postedOwn(await crossing(() => deliver(this.slack, this.options.identity.ownerUserId, this.place, chunk, [{ type: "markdown", text: chunk }], { ephemeral: options.ownerOnly ?? false })));
+            this.written();
+        }
+    }
+    async acknowledge(message) {
+        if (this.stopped.aborted)
+            return;
+        try {
+            await this.slack.reactions.add({
+                channel: this.channel,
+                name: "white_check_mark",
+                timestamp: message,
+            });
+        }
+        catch (error) {
+            logger.warning(`could not react to a word in ${this.channel}: ${describe(error)}`);
+        }
+    }
+    async link(label, markup) {
+        let permalink;
+        try {
+            ({ permalink } = await this.slack.chat.getPermalink({
+                channel: this.channel,
+                message_ts: this.threadTs,
+            }));
+            if (typeof permalink !== "string")
+                throw new TypeError("no permalink");
+        }
+        catch (error) {
+            logger.warning(`could not get a permalink for ${this.channel}/${this.threadTs}: ${describe(error)}`);
+            return null;
+        }
+        // A notice is mrkdwn, which takes `<url|label>`; a reference is Markdown, `[label](url)`.
+        return markup === "notice" ? `<${permalink}|${label}>` : `[${label}](${permalink})`;
+    }
+    endReply(reply, note) {
+        return endReply(this.slack, this.options.limiter, this.place, reply, note);
+    }
+    async close() {
+        // The list that was just taken off a reply the session no longer tracks only debounced:
+        // nothing else would write it before the process ends.
+        await this.places?.settleListed();
+        // The replies this object opened are let go of, their end landed or not: the session that
+        // held them is over, and nothing else would drop them from the thread's places.
+        for (const [places, reply] of this.opened)
+            places.closed(reply);
+        this.opened.length = 0;
+        if (this.places !== null) {
+            this.places = null;
+            this.lease.give();
+        }
+        await this.line.close();
+    }
+    get place() {
+        return { channel: this.channel, threadTs: this.threadTs };
+    }
+}

package/dist/chat/slack/update.js

@@ -0,0 +1,71 @@
+/**
+ * The update of allaboard as Slack draws it (issue #361): the offer `!allaboard update` posts in a
+ * channel, and the button and dialog of the update line on the Home tab. The words are the
+ * core's; the click of either becomes a pick of the core (`app/update.ts`).
+ *
+ * The confirmation dialog object (docs.slack.dev/reference/block-kit/composition-objects/
+ * confirmation-dialog-object, read 2026-10-17): `title` holds 100 characters, `text` 300,
+ * `confirm` and `deny` 30 each, all `plain_text`; `style` is optional. A button's `value` holds
+ * 2,000 characters (button element reference): a version is far under it.
+ */
+import { fill, sharedCopyLine, texts } from "../../core/port.js";
+import { contextBlock, plainTextObject } from "./reply/blocks.js";
+import { take } from "./reply/chars.js";
+import { mrkdwnEscape } from "./reply/escape.js";
+import * as slackTexts from "./texts.js";
+// Block Kit's limits on a confirmation dialog: its title, its text, and each of its two buttons.
+export const CONFIRM_TITLE_LIMIT = 100;
+export const CONFIRM_TEXT_LIMIT = 300;
+export const CONFIRM_BUTTON_LIMIT = 30;
+/** The Update button of the offer a channel shows: its value is the version it installs. */
+export const UPDATE_ACTION = "update_install";
+/** The `block_id` of the offer's line, so a test and a rewrite can tell it from its notes. */
+export const UPDATE_BLOCK = "update";
+/** `line` followed by the link to the changelog at `url`, in mrkdwn. */
+export function withChangelog(line, url) {
+    return fill(slackTexts.UPDATE_LINKED, {
+        line,
+        url: mrkdwnEscape(url),
+        label: texts.UPDATE_WHAT_CHANGED,
+    });
+}
+/**
+ * The button that installs `latest`, with Slack's own confirmation dialog when `confirm` gives
+ * the version that runs: the Home tab shows no message that says what changes first, the offer
+ * in a channel does.
+ */
+export function updateButton(actionId, latest, confirm) {
+    const button = {
+        type: "button",
+        action_id: actionId,
+        text: plainTextObject(fill(texts.UPDATE_BUTTON, { latest })),
+        value: latest,
+    };
+    if (confirm !== null) {
+        button.confirm = {
+            title: plainTextObject(take(texts.UPDATE_CONFIRM_TITLE, CONFIRM_TITLE_LIMIT)),
+            text: plainTextObject(take(fill(texts.UPDATE_CONFIRM_TEXT, { installed: confirm.installed, latest }), CONFIRM_TEXT_LIMIT)),
+            confirm: plainTextObject(take(texts.UPDATE_CONFIRM_YES, CONFIRM_BUTTON_LIMIT)),
+            deny: plainTextObject(take(texts.UPDATE_CONFIRM_NO, CONFIRM_BUTTON_LIMIT)),
+        };
+    }
+    return button;
+}
+/**
+ * The offer: the line `title` with the link to what changed and the Update button, then what a
+ * click waits for, and the other instances that restart with this one when there are any. The
+ * message shows the change, so its button asks nothing more.
+ */
+export function updateBlocks(list, title) {
+    const shared = sharedCopyLine(list.sharing);
+    return [
+        {
+            type: "section",
+            block_id: UPDATE_BLOCK,
+            text: { type: "mrkdwn", text: withChangelog(title, list.changelog) },
+            accessory: updateButton(UPDATE_ACTION, list.to, null),
+        },
+        contextBlock(texts.UPDATE_DRAIN),
+        ...(shared === null ? [] : [contextBlock(shared)]),
+    ];
+}

package/dist/chat/slack/voice.js

@@ -0,0 +1,84 @@
+/**
+ * An audio clip as a prompt: the transcript Slack makes of it, sent as the owner's text.
+ *
+ * Claude Code takes no audio (its Read tool refuses a binary file, measured 2026-10-09, CLI
+ * 2.1.292), and its own dictation is the microphone of an interactive session. So a clip becomes a
+ * prompt the way dictation fills the terminal's input: as text, before the session sees it. The
+ * daemon never transcribes: the text is the one Slack makes when the owner asks for it with
+ * `Generate transcript` on the clip (Slack help, "Record audio and video clips", read 2026-10-09).
+ *
+ * Measured on 2026-10-09 (Slack free plan, slack-sdk 3.45.0), three clips recorded in the iOS app:
+ *
+ * - a clip is a message with no text and one file whose `media_display_type` is `audio`
+ *   (`mimetype` `audio/mp4`): a clip recorded in Slack has the `subtype` `slack_audio`, and the
+ *   same recording uploaded as a file has none and gets a transcript all the same;
+ * - nothing tells the app when the clip is sent; while Slack makes the transcript it sends
+ *   `file_change` for the file, four times in 15 seconds, and the last leaves
+ *   `transcription.status` at `complete`. Only `complete` was seen as a status;
+ * - `transcription.preview.content` is the text and `has_more` was false, up to 67 characters;
+ *   `vtt` is the whole transcript as WebVTT on Slack's file host, read with the bot token;
+ * - Slack picks the language itself (`transcription.locale`): of three clips spoken in Italian it
+ *   heard one as `it-IT` and two as `en-GB`, and the text of those two was wrong.
+ */
+import { strip } from "../../text.js";
+// How long a clip waits for the owner to ask Slack for its transcript.
+export const WAIT_SECONDS = 300.0;
+// A transcript of five minutes of speech, the longest clip Slack records, is a few kilobytes.
+export const VTT_LIMIT = 256 * 1024;
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * The audio a message is, when it carries that one file and nothing else: a clip recorded in
+ * Slack or an audio file, which Slack shows with the same player and transcript.
+ */
+export function clip(files) {
+    const [only] = files;
+    if (files.length === 1 && only && record(only)?.media_display_type === "audio")
+        return only;
+    return null;
+}
+/** Whether Slack has finished the transcript of `file`. */
+export function ready(file) {
+    return record(record(file)?.transcription)?.status === "complete";
+}
+/**
+ * The transcript when the file object holds all of it; null when Slack cut it (`has_more`) and
+ * the rest is in the file's `vtt`.
+ */
+export function preview(file) {
+    const found = record(record(record(file)?.transcription)?.preview);
+    if (found === null || found.has_more)
+        return null;
+    return typeof found.content === "string" ? strip(found.content) : null;
+}
+// A tag of a WebVTT cue: from `<` to the next `>`, across line ends, or to the end of the cue when
+// nothing closes it (WebVTT 1, the cue text tokenizer).
+const TAG = /<[^>]*(?:>|$)/g;
+/**
+ * The words of a WebVTT transcript as Slack writes it: a `WEBVTT` header, then cues of a timing
+ * line and text lines, the first of which can open with `- `. One line of text, without the tags
+ * WebVTT allows inside a cue (`<v Name>`, `<i>`), which Slack was not seen to write.
+ */
+export function vttText(body) {
+    const words = [];
+    for (const block of body.replace(/^+/, "").replaceAll("\r\n", "\n").split("\n\n")) {
+        const lines = block
+            .split("\n")
+            .map(strip)
+            .filter((line) => line !== "");
+        const timing = lines.findIndex((line) => line.includes("-->"));
+        if (timing === -1)
+            continue; // the header, or a note
+        const cue = lines
+            .slice(timing + 1)
+            .join("\n")
+            .replace(TAG, "");
+        for (const text of cue.split("\n")) {
+            words.push(strip(text.startsWith("- ") ? text.slice(2) : text));
+        }
+    }
+    return words.filter((word) => word !== "").join(" ");
+}