allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/app/clip.js

@@ -0,0 +1,191 @@
+/**
+ * An audio clip the owner sent: held until Slack has its transcript (`voice.ts`), then sent as
+ * the message the owner would have typed.
+ */
+import { fill, named, texts } from "../../../core/port.js";
+import { strip } from "../../../text.js";
+import { DownloadFailed } from "../attachments.js";
+import { describe } from "../reply/errors.js";
+import { mrkdwnEscape } from "../reply/escape.js";
+import { Task } from "../reply/tasks.js";
+import * as slackTexts from "../texts.js";
+import * as voice from "../voice.js";
+import { isCancelled, logger } from "./answers.js";
+import { isOwner } from "./guards.js";
+import { inboundMessage } from "./messages.js";
+import { record, str, text } from "./wire.js";
+export class Clips {
+    parts;
+    answers;
+    // Clips waiting for their transcript, by file id. In memory only: a restart forgets them,
+    // and the owner sends the clip again.
+    clips = new Map();
+    constructor(parts, answers) {
+        this.parts = parts;
+        this.answers = answers;
+    }
+    /**
+     * An audio clip is a prompt once Slack has its transcript, which Slack writes when asked:
+     * until then it waits, and the owner is told what to do. Where a typed message would be
+     * refused, the clip is refused at once, before any wait.
+     */
+    async takeClip(channel, threadTs, ts, event, file) {
+        const { identity, sessions, state } = this.parts;
+        if (!isOwner(identity, text(file.user), text(file.user_team))) {
+            await this.answers.tellOwnerAbout(channel, threadTs, ts, named(slackTexts.CLIP_NOT_YOURS, this.parts.names));
+            return;
+        }
+        if (threadTs !== ts && !sessions.live(channel, threadTs)) {
+            await this.answers.tellOwner(channel, threadTs, texts.NOT_A_SESSION);
+            return;
+        }
+        if (threadTs === ts && state.channel(channel) === null) {
+            await this.parts.inbound.unbound(channel);
+            return;
+        }
+        const waiting = { channel, threadTs, ts, event, expiry: null, notice: null };
+        if (voice.ready(file)) {
+            await this.sendClip(waiting, file);
+            return;
+        }
+        const fileId = str(file.id);
+        // the same file sent again: one wait, the later one, and one line that says so
+        const earlier = this.clips.get(fileId);
+        earlier?.expiry?.cancel();
+        waiting.expiry = new Task((signal) => this.giveUp(fileId, signal));
+        this.clips.set(fileId, waiting);
+        if (earlier !== undefined)
+            await this.endWait(earlier);
+        const notice = await this.say(waiting, named(slackTexts.CLIP_WAITING, this.parts.names));
+        // The wait can have ended while Slack took the line: nobody is left to take it back.
+        if (this.clips.get(fileId) === waiting)
+            waiting.notice = notice;
+        else if (notice !== null)
+            await this.answers.withdraw(channel, notice);
+    }
+    /**
+     * A line about the clip that stays: a normal post in the clip's thread, or in the channel
+     * for a clip at the top level. Returns its `ts`, null when it was not posted.
+     */
+    say(waiting, line) {
+        return this.answers.tellAbout(waiting.channel, waiting.threadTs, waiting.ts, line);
+    }
+    /** The wait is over, whichever way: the line that said the clip waits goes. */
+    async endWait(waiting) {
+        const notice = waiting.notice;
+        waiting.notice = null;
+        if (notice !== null)
+            await this.answers.withdraw(waiting.channel, notice);
+    }
+    async giveUp(fileId, signal) {
+        await this.parts.clock.sleep(voice.WAIT_SECONDS, signal);
+        // (sync) Taken out with nothing awaited since the sleep: a transcript that arrives now
+        // finds no clip, and one that arrived a moment ago cancelled this wait.
+        const waiting = this.clips.get(fileId);
+        if (waiting === undefined)
+            return;
+        this.clips.delete(fileId);
+        // Whole minutes: 300 seconds are 5 whichever way a tie rounds (`Math.round` goes up, Python's
+        // `round` to even).
+        const minutes = Math.round(voice.WAIT_SECONDS / 60);
+        await this.endWait(waiting);
+        // What follows is a post anyone in the channel reads, minutes after the clip passed the
+        // check: the channel is read again, and a refused one is said to the owner alone.
+        const { channel, threadTs, ts } = waiting;
+        if (!(await this.answers.channelAllowed(channel, threadTs, ts)))
+            return;
+        await this.say(waiting, fill(named(slackTexts.CLIP_NOT_SENT, this.parts.names), { minutes }));
+    }
+    /** Send the clip's transcript as the message the owner would have typed. */
+    async sendClip(waiting, file) {
+        let heard = voice.preview(file);
+        if (heard === null) {
+            let body;
+            try {
+                body = await this.parts.fetch({
+                    url: str(file.vtt),
+                    mimetype: "text/vtt",
+                    limit: voice.VTT_LIMIT,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof DownloadFailed))
+                    throw error;
+                await this.say(waiting, fill(named(slackTexts.CLIP_UNREADABLE, this.parts.names), {
+                    reason: mrkdwnEscape(error.message),
+                }));
+                return;
+            }
+            // A byte that is no UTF-8 becomes U+FFFD.
+            heard = voice.vttText(new TextDecoder("utf-8").decode(body));
+        }
+        if (!heard) {
+            await this.say(waiting, named(slackTexts.CLIP_EMPTY, this.parts.names));
+            return;
+        }
+        const typed = strip(text(waiting.event.text) ?? "");
+        // the composer's blocks describe the typed text alone
+        const { blocks: _blocks, ...rest } = waiting.event;
+        const said = { ...rest, text: typed ? `${typed}\n\n${heard}` : heard, files: [] };
+        await this.parts.inbound.message(inboundMessage(this.parts, this.answers, waiting.channel, waiting.threadTs, waiting.ts, said, { spoken: true }));
+    }
+    /**
+     * Slack changed a file: the one inbound path with no user and no channel in it. It acts only
+     * on a clip the owner's own message left waiting, and checks the owner and the channel again
+     * on the file Slack now describes.
+     */
+    onFileChange = async (event) => {
+        const { slack, identity } = this.parts;
+        const fileId = str(event.file_id || record(event.file).id || "");
+        if (!this.clips.has(fileId))
+            return;
+        let file;
+        try {
+            const answer = await slack.files.info({ file: fileId });
+            if (typeof answer.file !== "object" || answer.file === null) {
+                throw new TypeError("files.info answered no file");
+            }
+            file = answer.file;
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            logger.warning(`could not read a waiting clip: ${describe(error)}`);
+            return;
+        }
+        // (sync) Slack sends the event several times while it writes one transcript: the first
+        // that finds it complete takes the clip, with nothing awaited in between.
+        const waiting = this.clips.get(fileId);
+        if (waiting === undefined || !voice.ready(file))
+            return;
+        this.clips.delete(fileId);
+        waiting.expiry?.cancel();
+        // Started now and awaited last: the transcript never waits on the line's removal.
+        const lineGone = this.endWait(waiting);
+        try {
+            const user = text(file.user);
+            const team = text(file.user_team);
+            if (!isOwner(identity, user, team)) {
+                await this.answers.tellOwnerAbout(waiting.channel, waiting.threadTs, waiting.ts, named(slackTexts.CLIP_NOT_YOURS, this.parts.names));
+                return;
+            }
+            // The channel is read again: its members can have changed while the clip waited.
+            const { channel, threadTs, ts } = waiting;
+            if (!(await this.answers.admitted(user, team, channel, threadTs, ts)))
+                return;
+            await this.answers.replyOnFailure(channel, threadTs, () => this.sendClip(waiting, file));
+        }
+        finally {
+            await lineGone;
+        }
+    };
+    /**
+     * Give every wait up without a word: the daemon is stopping. A timer of Node's keeps the
+     * process alive until it fires.
+     */
+    close() {
+        for (const waiting of this.clips.values())
+            waiting.expiry?.cancel();
+        this.clips.clear();
+    }
+}

package/dist/chat/slack/app/guards.js

@@ -0,0 +1,162 @@
+/**
+ * Who may talk to the daemon, and in which channels it may answer.
+ *
+ * Every inbound path calls these on its own: a button is never trusted because of the message it
+ * sits on, and the channel is re-read from Slack each time, since membership can change.
+ */
+import { getLogger } from "../../../log.js";
+import { isSpace } from "../../../text.js";
+import { describe } from "../reply/errors.js";
+import * as slackTexts from "../texts.js";
+export const logger = getLogger("allaboard.chat.slack.app.guards");
+function text(value) {
+    return typeof value === "string" ? value : null;
+}
+/** Whether a parsed JSON value is present: `[]`, `{}`, `""`, `0`, `false` and null are not. */
+function truthy(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    switch (typeof value) {
+        case "object":
+            return Object.keys(value).length > 0;
+        case "string":
+            return value.length > 0;
+        case "number":
+            return value !== 0;
+        default:
+            return Boolean(value);
+    }
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+/** True only for the configured owner acting from the workspace read at startup. */
+export function isOwner(identity, userId, teamId) {
+    return Boolean(userId) && userId === identity.ownerUserId && teamId === identity.teamId;
+}
+/**
+ * The user and the workspace of a message, `body` being the envelope the event came in. Two
+ * events carry no `team`. A file_share (measured 2026-09-25): its files name the uploader's
+ * workspace, and must all name the same one. A thread_broadcast, a reply also sent to the
+ * channel (recorded 2026-10-09): the envelope's `team_id` stands in, and only when the envelope
+ * says the channel is not shared outside the workspace, since that id names where the event
+ * happened and not the writer's own workspace. One that carries files follows the files' rule,
+ * the stricter of the two.
+ */
+export function messageActor(event, body) {
+    let team;
+    // Only a missing or null `team` falls back: a value of another type is a team nobody has,
+    // never a reason to read the files or the envelope instead.
+    if (event.team !== undefined && event.team !== null) {
+        team = text(event.team);
+    }
+    else if (truthy(event.files)) {
+        team = filesTeam(event.files);
+    }
+    else if (event.subtype === "thread_broadcast" && body.is_ext_shared_channel === false) {
+        team = text(body.team_id);
+    }
+    else {
+        team = null;
+    }
+    return [text(event.user), team];
+}
+/**
+ * The one workspace all the files name, else null. A `files` that is not a list of objects names
+ * no workspace, which refuses the message.
+ */
+function filesTeam(files) {
+    if (!Array.isArray(files))
+        return null;
+    const teams = new Set(files.map((file) => text(record(file).user_team)));
+    const [only] = teams;
+    return teams.size === 1 && only !== undefined ? only : null;
+}
+/** The user and the workspace of a click; a user whose home team differs counts as foreign. */
+export function interactionActor(body) {
+    const user = record(body.user);
+    const team = text(record(body.team).id);
+    // The home team is compared as it came: only a missing or null one defers to `team`.
+    const home = user.team_id;
+    const same = home === undefined || home === null || (typeof home === "string" && home === team);
+    return [text(user.id), same ? team : null];
+}
+// The subtypes a message a person wrote can carry: a message with files, and a thread reply also
+// sent to the channel. Any other subtype is an edit, a deletion or a join.
+export const PROMPT_SUBTYPES = ["file_share", "thread_broadcast"];
+function hasText(value) {
+    return typeof value === "string" && [...value].some((char) => !isSpace(char.charCodeAt(0)));
+}
+/**
+ * A message a person wrote: with no subtype or one of PROMPT_SUBTYPES, from no bot, with some
+ * text or a file.
+ */
+export function isPromptMessage(event) {
+    // An absent subtype passes; a subtype that is present and null does not.
+    const subtype = "subtype" in event ? event.subtype : "file_share";
+    return (event.type === "message" &&
+        typeof subtype === "string" &&
+        PROMPT_SUBTYPES.includes(subtype) &&
+        !("bot_id" in event) &&
+        (hasText(event.text) || (Array.isArray(event.files) && event.files.length > 0)));
+}
+// The subtypes of a message a person wrote that sits in a thread whatever the daemon makes of it:
+// those of a prompt, and a `/me` line. Edits, deletions and joins are not new messages.
+const WRITTEN_SUBTYPES = [...PROMPT_SUBTYPES, "me_message"];
+/**
+ * A message a person wrote, prompt or not: it takes a place in its thread, below the replies
+ * above it, even when nothing is made of it (a `/me` line, a share with attachments alone).
+ */
+export function isWrittenMessage(event) {
+    const subtype = "subtype" in event ? event.subtype : "file_share";
+    return (event.type === "message" &&
+        typeof subtype === "string" &&
+        WRITTEN_SUBTYPES.includes(subtype) &&
+        !("bot_id" in event));
+}
+const SHARED_FLAGS = ["is_shared", "is_ext_shared", "is_org_shared", "is_pending_ext_shared"];
+export class ChannelGuard {
+    #slack;
+    #identity;
+    #log;
+    constructor(slack, identity, log = logger) {
+        this.#slack = slack;
+        this.#identity = identity;
+        this.#log = log;
+    }
+    /** Null when the channel is private, unshared and holds exactly the owner and the bot. */
+    async refusal(channelId) {
+        let info;
+        let members;
+        try {
+            const answer = await this.#slack.conversations.info({ channel: channelId });
+            if (answer.channel === undefined)
+                throw new Error("conversations.info answered no channel");
+            info = answer.channel;
+            members = await this.#slack.conversations.members({ channel: channelId, limit: 10 });
+        }
+        catch (error) {
+            // A network failure too: an unread channel is never trusted.
+            this.#log.warning(`could not read channel ${channelId}: ${describe(error)}`);
+            return slackTexts.REASON_UNREADABLE;
+        }
+        if (!truthy(info.is_private) || truthy(info.is_im) || truthy(info.is_mpim)) {
+            return slackTexts.REASON_NOT_PRIVATE;
+        }
+        if (SHARED_FLAGS.some((flag) => truthy(info[flag])))
+            return slackTexts.REASON_SHARED;
+        const more = truthy(members.response_metadata?.next_cursor);
+        if (members.members === undefined)
+            throw new Error("conversations.members answered no members");
+        const present = new Set(members.members);
+        const expected = new Set([this.#identity.ownerUserId, this.#identity.botUserId]);
+        const same = present.size === expected.size && [...present].every((id) => expected.has(id));
+        if (more || !same)
+            return slackTexts.REASON_MEMBERS;
+        return null;
+    }
+}

package/dist/chat/slack/app/home-controls.js

@@ -0,0 +1,91 @@
+/**
+ * The controls of the session index (the app's Home tab, `home.ts`): its filters, Show all, Edit,
+ * Delete, Clean up and the update line's button.
+ */
+import { EDIT_ON, readFilter } from "../home.js";
+import { logger } from "./answers.js";
+import { interactionActor, isOwner } from "./guards.js";
+import { firstAction, record, str } from "./wire.js";
+export class HomeControls {
+    parts;
+    home;
+    constructor(parts) {
+        this.parts = parts;
+        this.home = parts.home;
+    }
+    /**
+     * Whether a use of a Home tab control is the owner's. The page is published to the owner
+     * alone, and each use is still checked on its own, as every inbound path is; a Home tab
+     * payload names no channel, so there is none to guard.
+     */
+    homeOwner(body) {
+        if (this.parts.stopped.aborted)
+            return false; // the daemon is gone: nothing to publish or delete
+        const [user, team] = interactionActor(body);
+        if (isOwner(this.parts.identity, user, team))
+            return true;
+        logger.info("ignored an inbound event from someone other than the owner");
+        return false;
+    }
+    // The Home tab's link button: Slack follows the link itself and still sends the click, which
+    // only needs acknowledging. Nothing is read from it and nothing is done, whoever clicked.
+    onHomeLink = async (ack) => {
+        await ack();
+    };
+    onHomeFilter = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        // The controls' own state rides on the payload: every filter is read from it at once.
+        const values = record(record(body.view).state).values;
+        await this.home.choose(readFilter(values, this.home.chosen));
+    };
+    onHomeShowAll = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        // Showing all of a channel is choosing that channel in the filter (`Home.choose` checks it
+        // is a bound one).
+        const channel = str(firstAction(body).value);
+        await this.home.choose({ ...this.home.chosen, channel });
+    };
+    onHomeEdit = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        await this.home.edit(str(firstAction(body).value) === EDIT_ON);
+    };
+    // Slack sends this click only once the owner confirmed in the button's own dialog.
+    onHomeDelete = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        // The value names the thread; `Home.delete` deletes only one `state.json` holds.
+        const value = str(firstAction(body).value);
+        const at = value.indexOf(":");
+        const channel = at === -1 ? value : value.slice(0, at);
+        const threadTs = at === -1 ? "" : value.slice(at + 1);
+        await this.home.delete(channel, threadTs);
+    };
+    // Sent, like Delete, only once the owner confirmed in the button's own dialog.
+    onHomeClean = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        await this.home.clean(str(firstAction(body).value));
+    };
+    // Sent only once the owner confirmed in the button's own dialog. The page has no message and no
+    // channel to answer in: the click reaches the core without either, and the page shows the state.
+    onHomeUpdate = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        // The version is the button's value, untrusted like every click's.
+        await this.parts.inbound.picked({
+            type: "update",
+            channel: null,
+            version: str(firstAction(body).value),
+            list: null,
+        });
+    };
+}

package/dist/chat/slack/app/messages.js

@@ -0,0 +1,181 @@
+/**
+ * A message the owner wrote, read from Slack's payload into the message the core is told of
+ * (`InboundMessage`): its text as typed and with the composer's marks removed, whether it
+ * carries files or was spoken, and the prompt its files make. What the message means, where it
+ * is routed and in what order it is sent are the core's (`core/flows/messages.ts`).
+ *
+ * Ordering. The core takes a thread's messages in the order they were handed over, although
+ * files take a while to download. The provider keeps its part: the listener takes its place among
+ * its thread's messages before its channel check (`ThreadOrder`), so the messages are handed
+ * over in the order the listeners were called, and from the check to the call
+ * `ChatInbound.message` nothing is awaited (`(sync)` in `app.ts`). `content` is read by the core
+ * inside the message's own turn.
+ */
+import { fill, named } from "../../../core/port.js";
+import { strip } from "../../../text.js";
+import { DownloadFailed, imagesRefusal, isImage, limitFor, promptFor, refusal, save, } from "../attachments.js";
+import { mrkdwnEscape } from "../reply/escape.js";
+import * as slackTexts from "../texts.js";
+import { items, str, text } from "./wire.js";
+// Slack sends a link as <url|label> or <url> (message formatting reference, read 2026-09-25).
+// Mentions (<@U…>, <#C…>) stay as sent: naming them would need a scope the app does not have.
+const LINK = /<((?:https?|mailto):[^|>]+)(?:\|([^>]+))?>/g;
+const SCHEME = /^(?:https?:\/\/|mailto:)/;
+function link(_whole, url, label) {
+    if (label === undefined)
+        return url;
+    // A link Slack made from a typed name carries that name as its label; one the owner named
+    // keeps its address, which the agent needs to open it.
+    return url.replace(SCHEME, "") === label ? label : `${label} (${url})`;
+}
+/** The text as the owner typed it, with the address of any link the owner named. */
+export function slackUnescape(sent) {
+    return sent
+        .replace(LINK, link)
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("&amp;", "&");
+}
+// The parts of a composer message a word is read through. A quote or a list is left out: what
+// opens it is not what the owner typed first.
+const READ_THROUGH = new Set(["rich_text_section", "rich_text_preformatted"]);
+// What Slack writes in a message's text around code, bold, italic, strikethrough.
+const MARKS = "`*_~";
+/** The first element of a list, or an empty record for anything else. */
+function firstOf(value) {
+    const head = Array.isArray(value) ? value[0] : undefined;
+    return typeof head === "object" && head !== null ? head : {};
+}
+/**
+ * The text a composer message opens with, without its formatting; null for a message that opens
+ * with anything else (a quote, a list, an emoji, a mention) or has no composer block.
+ */
+function firstRun(blocks) {
+    const block = firstOf(blocks);
+    const part = block.type === "rich_text" ? firstOf(block.elements) : {};
+    const leaf = typeof part.type === "string" && READ_THROUGH.has(part.type) ? firstOf(part.elements) : {};
+    if (leaf.type !== "text")
+        return null;
+    return typeof leaf.text === "string" ? leaf.text : "";
+}
+/**
+ * `text` without the marks around the run it opens with, when that run starts with `!`: the
+ * composer's block says what the run is (`firstRun`), the text holds the rest as the owner sent
+ * it. Empty when the message does not open with a formatted `!`, or when the text does not read as
+ * its marks, that run, then the same marks closing it or the message.
+ */
+export function unformatted(text, blocks) {
+    const run = firstRun(blocks);
+    const stripped = strip(text);
+    const at = stripped.indexOf("!");
+    const opening = at === -1 ? stripped : stripped.slice(0, at);
+    const body = at === -1 ? "" : stripped.slice(at);
+    if (!run?.startsWith("!") || !opening || [...opening].some((c) => !MARKS.includes(c))) {
+        return "";
+    }
+    if (!body.startsWith(run))
+        return "";
+    const after = body.slice(run.length);
+    const closing = [...opening].reverse().join("");
+    if (after.startsWith(closing))
+        return run + after.slice(closing.length);
+    if (after.endsWith(closing))
+        return run + after.slice(0, after.length - closing.length);
+    return "";
+}
+/**
+ * The files a message carries. A `files` that is not a list of objects throws: such a message
+ * never becomes a prompt, and never a word either.
+ */
+export function filesOf(event) {
+    const files = event.files;
+    if (files === undefined || files === null)
+        return [];
+    if (!Array.isArray(files))
+        throw new TypeError("the message's files are not a list");
+    return items(files).map((file) => {
+        if (typeof file !== "object" || file === null || Array.isArray(file)) {
+            throw new TypeError("a file of the message is not an object");
+        }
+        return file;
+    });
+}
+/**
+ * The prompt for `sent` and its files; null, after telling the owner why under the message `ts`,
+ * when any file cannot reach the agent: the message is sent whole or not at all.
+ */
+async function withAttachments(parts, answers, channel, threadTs, ts, sent, files) {
+    const { fetch, uploads } = parts;
+    const refuse = async (file, reason) => {
+        const name = mrkdwnEscape(str(file.name || file.id));
+        await answers.tellOwnerAbout(channel, threadTs, ts, fill(named(slackTexts.UPLOAD_FAILED, parts.names), { name, reason }));
+    };
+    for (const file of files) {
+        const reason = refusal(file, parts.names);
+        if (reason !== null) {
+            await refuse(file, reason);
+            return null;
+        }
+    }
+    const together = imagesRefusal(files, parts.names);
+    if (together !== null) {
+        await answers.tellOwnerAbout(channel, threadTs, ts, together);
+        return null;
+    }
+    const fetched = await Promise.allSettled(files.map((file) => fetch({
+        url: str(file.url_private_download),
+        mimetype: str(file.mimetype),
+        limit: limitFor(file),
+    })));
+    // Nothing is saved until every file arrived: a failed message leaves no copy behind.
+    for (const [index, outcome] of fetched.entries()) {
+        if (outcome.status === "fulfilled")
+            continue;
+        if (outcome.reason instanceof DownloadFailed) {
+            await refuse(files[index], fill(slackTexts.UPLOAD_DOWNLOAD, { error: outcome.reason.message }));
+            return null;
+        }
+        throw outcome.reason;
+    }
+    const images = [];
+    const paths = [];
+    for (const [index, outcome] of fetched.entries()) {
+        const file = files[index];
+        if (outcome.status !== "fulfilled")
+            continue;
+        if (isImage(file)) {
+            images.push({ mediaType: str(file.mimetype), data: outcome.value });
+            continue;
+        }
+        try {
+            paths.push(await save(uploads, file, outcome.value));
+        }
+        catch (error) {
+            if (!(error instanceof DownloadFailed))
+                throw error;
+            await refuse(file, error.message);
+            return null;
+        }
+    }
+    return promptFor(sent, images, paths);
+}
+/**
+ * The message `event` is, for the core: written in `channel`, in the thread `threadTs`, with
+ * the timestamp `ts`. With `spoken` (a clip's transcript) it is literal whatever its text; so is
+ * a message with files, whose `content` downloads them when the core takes the message's turn.
+ * Throws when the event's `files` are not a list of objects.
+ */
+export function inboundMessage(parts, answers, channel, threadTs, ts, event, options = {}) {
+    const sent = slackUnescape(text(event.text) ?? "");
+    const files = filesOf(event);
+    return {
+        ref: { channel, thread: threadTs },
+        id: ts,
+        topLevel: threadTs === ts,
+        text: sent,
+        // The composer's blocks tell a mark around a `!` from the text alone.
+        plain: unformatted(sent, event.blocks) || sent,
+        literal: files.length > 0 || (options.spoken ?? false),
+        content: async () => files.length > 0 ? withAttachments(parts, answers, channel, threadTs, ts, sent, files) : sent,
+    };
+}