allaboard 0.0.0-stage → 0.5.0

package/dist/chat/slack/module.js

@@ -0,0 +1,174 @@
+/**
+ * The Slack module: the chat registry's entry for Slack. `build` makes everything of the Slack
+ * side that does not need the core (the clients, the identity `auth.test` gives, the provider,
+ * the thread deleter, the Home tab, the channel guard, the uploads folder); what needs the core
+ * is read through `context.core()` when it is first used, which is after `build` returned.
+ */
+import { createHash } from "node:crypto";
+import { ConfigError, } from "../../core/port.js";
+import { ChatError } from "../seam.js";
+import { socketReceiver } from "./app/app.js";
+import { ChannelGuard } from "./app/guards.js";
+import { prepareUploads } from "./attachments.js";
+import { ThreadDeleter } from "./delete.js";
+import { Home } from "./home.js";
+import { repliesClient, sharedClient } from "./reply/clients.js";
+import { describe } from "./reply/errors.js";
+import { UpdateLimiter } from "./reply/limiter.js";
+import { SlackChat } from "./thread.js";
+/**
+ * The daemon's two Slack clients on one token (the retry policy is in `reply/clients.ts`): the
+ * shared one for everything but a reply, and the one replies are written with.
+ */
+export function makeClients(botToken, options = {}) {
+    return [sharedClient(botToken, options), repliesClient(botToken, options)];
+}
+export const CLIENTS = {
+    bot: (token, stopped) => makeClients(token, stopped === undefined ? {} : { stopped }),
+    owner: (token) => sharedClient(token),
+};
+/** The text of a field `auth.test` must answer, which a log line and an identity rely on. */
+export function authField(answer, key) {
+    const value = answer[key];
+    if (typeof value !== "string" || value === "")
+        throw new Error(`auth.test answered no ${key}`);
+    return value;
+}
+/**
+ * What deletes a thread for the Home tab, when the owner's user token is configured. The token
+ * must be the owner's own, in the bot's workspace: it deletes as whoever it belongs to.
+ */
+export async function deleter(userToken, slack, identity, state, sessions, names, clients = CLIENTS) {
+    if (userToken === null)
+        return null;
+    const owner = clients.owner(userToken);
+    const who = await owner.auth.test();
+    if (authField(who, "user_id") !== identity.ownerUserId ||
+        authField(who, "team_id") !== identity.teamId) {
+        throw new ConfigError("SLACK_USER_TOKEN must be the owner's own token, in the bot's workspace");
+    }
+    return new ThreadDeleter(slack, owner, {
+        botUserId: identity.botUserId,
+        ownerUserId: identity.ownerUserId,
+        state,
+        names,
+        release: (channelId, threadId) => sessions.release(channelId, threadId),
+        free: (channelId, threadId) => sessions.free(channelId, threadId),
+    });
+}
+/**
+ * The lock key of an app-level token: its SHA-256 in hex, so that the key says which app without
+ * the token ever leaving this module (Slack documents no call that maps an `xapp-` token to its
+ * app).
+ */
+export function appTokenKey(appToken) {
+    return `app-token:${createHash("sha256").update(appToken).digest("hex")}`;
+}
+/** The variable `context` must hold for `name`: the daemon does not start without the required. */
+function variable(context, name) {
+    const value = context.variables[name];
+    if (value === undefined)
+        throw new ConfigError(`${name} is not set`);
+    return value;
+}
+/** The shape of each token, checked before Slack is called: a swapped pair is told at once. */
+function checkTokens(context) {
+    if (!variable(context, "SLACK_BOT_TOKEN").startsWith("xoxb-")) {
+        throw new ConfigError("SLACK_BOT_TOKEN must be the Bot User OAuth Token (xoxb-...)");
+    }
+    if (!variable(context, "SLACK_APP_TOKEN").startsWith("xapp-")) {
+        throw new ConfigError("SLACK_APP_TOKEN must be the app-level token (xapp-...)");
+    }
+    const userToken = context.variables.SLACK_USER_TOKEN;
+    if (userToken !== undefined && !userToken.startsWith("xoxp-")) {
+        throw new ConfigError("SLACK_USER_TOKEN must be the User OAuth Token (xoxp-...)");
+    }
+}
+/** The registry's entry for Slack. */
+export function slackChat(options = {}) {
+    return {
+        required: ["SLACK_BOT_TOKEN", "SLACK_APP_TOKEN", "SLACK_OWNER_USER_ID"],
+        optional: ["SLACK_USER_TOKEN"],
+        async build(context) {
+            checkTokens(context);
+            try {
+                return await assemble(options, context);
+            }
+            catch (error) {
+                // The daemon logs a start that failed by the name of its error: Slack's code, as before.
+                if (error instanceof ConfigError || error instanceof ChatError)
+                    throw error;
+                throw new ChatError(describe(error), { cause: error });
+            }
+        },
+    };
+}
+/** Everything of the Slack side that does not need the core. */
+async function assemble(options, context) {
+    const botToken = variable(context, "SLACK_BOT_TOKEN");
+    const appToken = variable(context, "SLACK_APP_TOKEN");
+    const clients = options.clients ?? CLIENTS;
+    // The clients are built before the chat that stops them: its stop is passed on below.
+    const stopping = new AbortController();
+    const [slack, replySlack] = clients.bot(botToken, stopping.signal);
+    const auth = await slack.auth.test();
+    const identity = {
+        ownerUserId: variable(context, "SLACK_OWNER_USER_ID"),
+        teamId: authField(auth, "team_id"),
+        botUserId: authField(auth, "user_id"),
+    };
+    const limiter = new UpdateLimiter({ clock: context.steady });
+    // What the Slack side asks of the core is read here when it is asked: the core is built
+    // after this provider is, and `context.core()` is not ready until then.
+    const state = {
+        thread: (channelId, threadId) => context.core().state.thread(channelId, threadId),
+        channels: () => context.core().state.channels(),
+        threads: () => context.core().state.threads(),
+        removeThread: (channelId, threadId) => context.core().state.removeThread(channelId, threadId),
+    };
+    // The provider is made last, from these parts; they ask it for the names when they show a
+    // line, which is after the core exists.
+    const names = () => chat.names();
+    const threadDeleter = await deleter(context.variables.SLACK_USER_TOKEN ?? null, slack, identity, state, {
+        release: (channelId, threadId) => context.core().sessions.release(channelId, threadId),
+        free: (channelId, threadId) => context.core().sessions.free(channelId, threadId),
+    }, names, clients);
+    const home = new Home(slack, {
+        ownerUserId: identity.ownerUserId,
+        teamId: identity.teamId,
+        state,
+        names,
+        sessionsOf: (directory) => context.core().agent.listSessions(directory),
+        ...(threadDeleter !== null && {
+            delete: (channelId, threadId) => threadDeleter.delete(channelId, threadId),
+            clean: (channelId) => threadDeleter.clean(channelId),
+        }),
+        update: () => context.core().updates?.line() ?? null,
+        clock: context.clock,
+    });
+    const uploads = options.uploads ?? context.scratchDir;
+    await prepareUploads(uploads);
+    const chat = new SlackChat({
+        slack,
+        replies: replySlack,
+        identity,
+        limiter,
+        clock: context.clock,
+        steady: context.steady,
+        agent: () => context.core().agent,
+        app: {
+            core: () => context.core(),
+            config: { botToken, allowedRoot: context.allowedRoot },
+            guard: new ChannelGuard(slack, identity),
+            home,
+            uploads,
+            receiver: (options.receiver ?? socketReceiver)(appToken),
+            appKey: appTokenKey(appToken),
+            ...(options.fetch !== undefined && { fetch: options.fetch }),
+            ...(options.listings !== undefined && { listings: options.listings }),
+            ...(options.now !== undefined && { now: options.now }),
+        },
+    });
+    chat.stopped.addEventListener("abort", () => stopping.abort(), { once: true });
+    return chat;
+}

package/dist/chat/slack/notice.js

@@ -0,0 +1,64 @@
+import { Cancelled } from "../../core/port.js";
+import { ChatError } from "../seam.js";
+import { contextBlock, FALLBACK_LIMIT, noticeText } from "./reply/blocks.js";
+import { take } from "./reply/chars.js";
+import { describe } from "./reply/errors.js";
+/**
+ * One message to `place`: a normal post or, with `ephemeral`, one only `ownerUserId` sees. A
+ * normal post pushes only inside a thread the owner started; an ephemeral message never does.
+ * `blocks` are built to Block Kit's reference by the modules that make them: opaque to the
+ * library's types. Returns the `ts` of a normal post, which `chat.delete` takes; null for an
+ * ephemeral message, which Slack lets nobody delete or update.
+ */
+export async function deliver(slack, ownerUserId, place, text, blocks, options) {
+    const where = place.threadTs === null ? {} : { thread_ts: place.threadTs };
+    const shown = blocks;
+    if (options.ephemeral) {
+        await slack.chat.postEphemeral({
+            channel: place.channel,
+            user: ownerUserId,
+            text: take(text, FALLBACK_LIMIT),
+            blocks: shown,
+            ...where,
+        });
+        return null;
+    }
+    const posted = await slack.chat.postMessage({
+        channel: place.channel,
+        text: take(text, FALLBACK_LIMIT),
+        blocks: shown,
+        unfurl_links: false,
+        unfurl_media: false,
+        ...where,
+    });
+    return posted.ts ?? null;
+}
+/** One of the daemon's notices, small and grey as the footer; `text` is mrkdwn. */
+export function deliverNotice(slack, ownerUserId, place, text, options) {
+    return deliver(slack, ownerUserId, place, text, [contextBlock(noticeText(text))], options);
+}
+/**
+ * `call`, with a failure crossing the seam as a `ChatError` named by Slack's code. A `Cancelled`
+ * is no failure of the chat: it crosses as it is.
+ */
+export async function crossing(call) {
+    try {
+        return await call();
+    }
+    catch (error) {
+        if (error instanceof Cancelled)
+            throw error;
+        throw new ChatError(describe(error), { cause: error });
+    }
+}
+/**
+ * The message `ts` rewritten into a notice that says `text`, with nothing left to press: an edit
+ * (silent), against the app's `chat.update` budget, which every reply draws from. Rejects with a
+ * `ChatError` named by Slack's code.
+ */
+export function rewriteAsNotice(slack, limiter, channel, ts, text) {
+    return crossing(async () => {
+        await limiter.acquire();
+        await slack.chat.update({ channel, ts, text, blocks: [contextBlock(noticeText(text))] });
+    });
+}

package/dist/chat/slack/openfile/modal.js

@@ -0,0 +1,362 @@
+/**
+ * The picker `!open` shows: the message with its button, the modal with its search field and its
+ * rows, what Slack sends back from it, and the order its updates are written in.
+ */
+import { createHash } from "node:crypto";
+import { fill, Semaphore } from "../../../core/port.js";
+import { isRecord } from "../../../values.js";
+import { contextBlock, plainTextObject } from "../reply/blocks.js";
+import { len, take } from "../reply/chars.js";
+import { shownAsWritten } from "../reply/escape.js";
+import * as slackTexts from "../texts.js";
+// The button that opens the picker's modal (in the `!open` message and in the one of several
+// matches), the modal's callback id, and the ids of its two input blocks. Slack keeps the state
+// of an input block whose ids do not change across `views.update` (reference, read 2026-10-05
+// and 2026-10-06), so the search field keeps its ids, to keep what was typed, and the rows' block
+// id, which is CHOICE_BLOCK and a mark of the rows it holds, changes with them, to drop a row
+// chosen among others.
+export const OPEN_BUTTON_ACTION = "open_choose";
+export const OPEN_FORM = "open_form";
+export const QUERY_BLOCK = "open_query_block";
+export const QUERY_ACTION = "open_query";
+export const CHOICE_BLOCK = "open_choice_block";
+export const CHOICE_ACTION = "open_choice";
+// Block Kit's limits, read 2026-10-05: a radio button group holds 10 options (radio button group
+// element); an option's `text` and its `description` 75 characters, its `value` 150 (option
+// object); a modal's `private_metadata` 3000 characters, its title, submit and close text 24, and
+// it holds 100 blocks (modal views).
+export const ROW_LIMIT = 10;
+export const TEXT_LIMIT = 75;
+export const DESCRIPTION_LIMIT = 75;
+export const VALUE_LIMIT = 150;
+// The words a search carries: typed in the field, or in a button's value from `!open <words>`.
+export const QUERY_LIMIT = 200;
+// A click waits until this long (seconds) after it arrived for the rows before the modal opens
+// without them: the click's `trigger_id` lives 3 seconds (views.open reference, read 2026-10-05),
+// which the channel check, this wait and `views.open` share, and the rows are put in by an update
+// when they come later.
+export const OPEN_WAIT = 1.0;
+// MODALS_KEPT modals are tracked at most (`ModalUpdates`).
+export const MODALS_KEPT = 16;
+/** `text` cut in its middle with `…` to `room` characters, its end kept longer than its start so an extension stays. */
+function middle(text, room) {
+    const characters = Array.from(text);
+    if (characters.length <= room)
+        return text;
+    const end = Math.floor((room - 1) / 2) + ((room - 1) % 2);
+    return `${characters.slice(0, room - 1 - end).join("")}…${characters.slice(characters.length - end).join("")}`;
+}
+/** Whether a path can be an option's value; the file stays reachable by `!open <path>`. */
+export function fits(path) {
+    return len(path) <= VALUE_LIMIT;
+}
+/**
+ * A row for a path: the file's name as plain text, so that nothing in it is read as markup or as
+ * an emoji (shortened in its middle past TEXT_LIMIT), its folder below it (shortened from the left
+ * past DESCRIPTION_LIMIT, left out for a file at the root of the session's folder), the path
+ * itself as the value. Null when the value cannot fit.
+ */
+export function option(path) {
+    if (!fits(path))
+        return null;
+    const slash = path.lastIndexOf("/");
+    const folder = slash < 0 ? "" : path.slice(0, slash);
+    const name = path.slice(slash + 1);
+    const row = {
+        text: plainTextObject(middle(name, TEXT_LIMIT), false),
+        value: path,
+    };
+    if (folder) {
+        const shown = len(folder) <= DESCRIPTION_LIMIT
+            ? folder
+            : `…${Array.from(folder)
+                .slice(-(DESCRIPTION_LIMIT - 1))
+                .join("")}`;
+        row.description = plainTextObject(shown);
+    }
+    return row;
+}
+/** The first ROW_LIMIT paths that make a row. */
+export function options(paths) {
+    const found = [];
+    for (const path of paths) {
+        if (found.length >= ROW_LIMIT)
+            break;
+        const shown = option(path);
+        if (shown !== null)
+            found.push(shown);
+    }
+    return found;
+}
+/** Metadata that `Target.dump` did not write. */
+export class BadTarget extends Error {
+    constructor(reason) {
+        super(reason);
+        this.name = "BadTarget";
+    }
+}
+/**
+ * The thread a modal belongs to, carried by the modal itself (`private_metadata`). It comes back
+ * from Slack and is untrusted: the handlers resolve it to the folder of that thread's own session
+ * and refuse anything else.
+ */
+export class Target {
+    channel;
+    threadTs;
+    constructor(channel, threadTs) {
+        this.channel = channel;
+        this.threadTs = threadTs;
+    }
+    dump() {
+        return JSON.stringify({ c: this.channel, t: this.threadTs });
+    }
+    /** Throws `BadTarget` for anything `dump` did not write. */
+    static load(text) {
+        if (typeof text !== "string")
+            throw new BadTarget("no metadata");
+        let data;
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            throw new BadTarget("not json");
+        }
+        if (!isRecord(data))
+            throw new BadTarget("not an object");
+        const { c: channel, t: threadTs } = data;
+        if (typeof channel !== "string" || typeof threadTs !== "string") {
+            throw new BadTarget("no thread");
+        }
+        return new Target(channel, threadTs);
+    }
+}
+function own(record, key) {
+    return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+/** The state of one element in a view's `state.values` (block id, then action id), `{}` for any shape Slack does not send. */
+function field(values, block, action) {
+    const found = isRecord(values) ? own(values, block) : undefined;
+    const element = isRecord(found) ? own(found, action) : undefined;
+    return isRecord(element) ? element : {};
+}
+/** The text in the search field, from a view's `state.values`; `""` when there is none. */
+export function typedIn(values) {
+    const value = field(values, QUERY_BLOCK, QUERY_ACTION).value;
+    return typeof value === "string" ? value : "";
+}
+/** The block of rows in a view's own `blocks`; null when the view shows none. */
+export function choiceBlock(view) {
+    const blocks = isRecord(view) ? view.blocks : undefined;
+    for (const block of Array.isArray(blocks) ? blocks : []) {
+        if (isRecord(block) &&
+            typeof block.block_id === "string" &&
+            block.block_id.startsWith(`${CHOICE_BLOCK}:`)) {
+            return block;
+        }
+    }
+    return null;
+}
+/**
+ * The value of the row chosen in a view as Slack sends it back (`blocks` and `state.values`), null
+ * when none is. Only a row of the block the view shows counts: the state of a block with an id
+ * that is gone, or a value that is not among its options, is a choice made among other rows.
+ */
+export function chosenIn(view) {
+    const block = choiceBlock(view);
+    if (!isRecord(view) || block === null)
+        return null;
+    const state = view.state;
+    const values = isRecord(state) ? state.values : undefined;
+    const chosen = field(values, block.block_id, CHOICE_ACTION).selected_option;
+    const value = isRecord(chosen) ? chosen.value : undefined;
+    const element = block.element;
+    const shown = isRecord(element) ? element.options : undefined;
+    const offered = new Set(Array.isArray(shown) ? shown.filter(isRecord).map((offer) => offer.value) : []);
+    return typeof value === "string" && offered.has(value) ? value : null;
+}
+function chooseButton(words) {
+    return {
+        type: "actions",
+        elements: [
+            {
+                type: "button",
+                action_id: OPEN_BUTTON_ACTION,
+                text: plainTextObject(slackTexts.OPEN_BUTTON),
+                ...(words ? { value: take(words, QUERY_LIMIT) } : {}),
+            },
+        ],
+    };
+}
+/** What `!open` alone posts: the button that opens the modal, and the way to open by name. */
+export function pickerBlocks() {
+    return [
+        { type: "section", text: { type: "mrkdwn", text: slackTexts.OPEN_TITLE } },
+        chooseButton(""),
+        contextBlock(slackTexts.OPEN_BY_NAME),
+    ];
+}
+/**
+ * Files match `words`: how many, and the button that opens the modal with `words` in its field;
+ * or, when no path is short enough to be a row, the line that says so. With `complete` false the
+ * line that says the folder could not be listed in full comes last.
+ */
+export function matchesBlocks(words, found, complete = true) {
+    const heading = {
+        type: "section",
+        text: {
+            type: "mrkdwn",
+            text: fill(found.length === 1 ? slackTexts.OPEN_MATCHES_ONE : slackTexts.OPEN_MATCHES, {
+                count: found.length,
+                words: shownAsWritten(words),
+            }),
+        },
+    };
+    const blocks = [
+        heading,
+        found.some(fits) ? chooseButton(words) : contextBlock(slackTexts.OPEN_MATCHES_TOO_LONG),
+    ];
+    return complete ? blocks : [...blocks, contextBlock(slackTexts.OPEN_PARTIAL)];
+}
+/** What the block of these rows is told apart by: the same rows, the same mark. */
+function mark(rows) {
+    const values = rows.map((row) => row.value).join("\0");
+    return createHash("sha256").update(values, "utf8").digest("hex").slice(0, 8);
+}
+/**
+ * The picker's modal for `target`: the search field holding `words`, and one row for each of the
+ * first ROW_LIMIT of `paths`, which are the session's changed files (newest first) while `words`
+ * is empty and the files matching it otherwise; null while they are still being listed. `opening`
+ * is the view `views.open` takes: it alone sets the field's initial value and focus, since an
+ * update keeps what was typed through the field's ids and must not restate it.
+ */
+export function modalView(target, words, paths, { count, complete = true, opening = false } = {}) {
+    const query = {
+        type: "plain_text_input",
+        action_id: QUERY_ACTION,
+        max_length: QUERY_LIMIT,
+        placeholder: plainTextObject(slackTexts.OPEN_QUERY_HINT),
+        dispatch_action_config: { trigger_actions_on: ["on_character_entered"] },
+        ...(opening ? { focus_on_load: true, ...(words ? { initial_value: words } : {}) } : {}),
+    };
+    const blocks = [
+        {
+            type: "input",
+            block_id: QUERY_BLOCK,
+            dispatch_action: true,
+            optional: true,
+            label: plainTextObject(slackTexts.OPEN_QUERY_LABEL),
+            element: query,
+        },
+    ];
+    if (paths === null) {
+        blocks.push(contextBlock(slackTexts.OPEN_LOADING));
+    }
+    else {
+        const rows = options(paths);
+        const total = count ?? paths.length;
+        let heading;
+        if (words) {
+            heading = fill(total === 1 ? slackTexts.OPEN_ROWS_MATCH_ONE : slackTexts.OPEN_ROWS_MATCH, {
+                count: total,
+            });
+        }
+        else if (total) {
+            heading = fill(slackTexts.OPEN_ROWS_CHANGED, { count: total });
+        }
+        else {
+            heading = slackTexts.OPEN_TYPE_A_NAME;
+        }
+        if (rows.length > 0) {
+            blocks.push({
+                type: "input",
+                block_id: `${CHOICE_BLOCK}:${mark(rows)}`,
+                optional: true,
+                label: plainTextObject(heading),
+                element: { type: "radio_buttons", action_id: CHOICE_ACTION, options: rows },
+            });
+        }
+        else {
+            blocks.push(contextBlock(heading));
+        }
+        if (total > rows.length) {
+            blocks.push(contextBlock(rows.length > 0
+                ? fill(slackTexts.OPEN_MATCHES_CAPPED, { shown: rows.length, count: total })
+                : slackTexts.OPEN_MATCHES_TOO_LONG));
+        }
+        if (!complete)
+            blocks.push(contextBlock(slackTexts.OPEN_PARTIAL));
+    }
+    return {
+        type: "modal",
+        callback_id: OPEN_FORM,
+        private_metadata: target.dump(),
+        title: plainTextObject(slackTexts.OPEN_MODAL_TITLE),
+        submit: plainTextObject(slackTexts.OPEN_MODAL_SUBMIT),
+        close: plainTextObject(slackTexts.OPEN_MODAL_CLOSE),
+        blocks,
+    };
+}
+/**
+ * Which update of an open modal may still be written, so that an older one never overwrites a
+ * newer one. Each keystroke reaches the daemon as its own `block_actions` event, handled on its
+ * own, and answers can finish in any order. The daemon is the only writer of its modals, so an
+ * update carries no `hash` (optional in `views.update`, reference read 2026-10-06): what orders
+ * the updates is a `key` (the event's `action_ts`; 0 for the first fill), and:
+ *
+ * - `claim` refuses a key that is not newer than one already taken, and any key of a view that was
+ *   forgotten;
+ * - `lock` lets one update of a view run at a time, and `current` says, once its turn has come and
+ *   again before it writes, whether it is still the newest;
+ * - `forget` drops a view whose modal was submitted, for good: nothing of it is tracked again.
+ *
+ * At most `limit` modals are tracked, the oldest dropped first (it is tracked again by its next
+ * update), and at most `limit` forgotten ones are remembered.
+ */
+export class ModalUpdates {
+    #limit;
+    #newest = new Map();
+    #locks = new Map();
+    #gone = new Set();
+    constructor(limit = MODALS_KEPT) {
+        this.#limit = limit;
+    }
+    /** Takes `key` as the newest of the view; false when one as new was taken already. */
+    claim(viewId, key) {
+        if (this.#gone.has(viewId) || key <= (this.#newest.get(viewId) ?? Number.NEGATIVE_INFINITY)) {
+            return false;
+        }
+        this.#newest.delete(viewId);
+        this.#newest.set(viewId, key);
+        while (this.#newest.size > this.#limit) {
+            this.#drop(this.#newest.keys().next().value);
+        }
+        return true;
+    }
+    /** Whether `key` is still the newest taken for the view. */
+    current(viewId, key) {
+        return this.#newest.get(viewId) === key;
+    }
+    /** The view's lock, one holder at a time; a forgotten view gets a lock that is kept nowhere. */
+    lock(viewId) {
+        if (this.#gone.has(viewId))
+            return new Semaphore(1);
+        let held = this.#locks.get(viewId);
+        if (held === undefined) {
+            held = new Semaphore(1);
+            this.#locks.set(viewId, held);
+        }
+        return held;
+    }
+    /** The view's modal was submitted: nothing of it is tracked again. */
+    forget(viewId) {
+        this.#drop(viewId);
+        this.#gone.add(viewId);
+        while (this.#gone.size > this.#limit) {
+            this.#gone.delete(this.#gone.values().next().value);
+        }
+    }
+    #drop(viewId) {
+        this.#newest.delete(viewId);
+        this.#locks.delete(viewId);
+    }
+}

package/dist/chat/slack/openfile/read.js

@@ -0,0 +1,29 @@
+/**
+ * What `!open` hands to Slack: the bytes the core read, shared into the thread. Which path may be
+ * read is the core's (`src/core/files/read.ts`).
+ */
+import { posix } from "node:path";
+import { titleOf } from "../../../core/port.js";
+// Slack's documented limit for a snippet: `snippet_too_large` on `files.getUploadURLExternal`
+// (docs.slack.dev/reference/methods/files.getUploadURLExternal, read 2026-10-05).
+export const SNIPPET_LIMIT = 1 << 20;
+/**
+ * Shares `content`, the bytes `readOpenable` read from `relative`, into the thread: the basename as
+ * the file's name and the path from the folder as its title, nothing posted on success. Rejects
+ * with Slack's error.
+ *
+ * `@slack/web-api` 8.2.0 types `content` as a string (`FileUploadStringContents`,
+ * `types/request/files.d.ts`) and encodes it as UTF-8, which would damage a binary file; its
+ * `file` field takes a `Buffer` as the bytes (a `string` there is a path read from disk,
+ * `dist/file-upload.js` `getFileData`). A Buffer is what is passed.
+ */
+export async function uploadFile(client, channel, threadTs, content, relative) {
+    const title = titleOf(relative);
+    await client.files.uploadV2({
+        channel_id: channel,
+        thread_ts: threadTs,
+        file: content,
+        filename: posix.basename(title),
+        title,
+    });
+}

package/dist/chat/slack/quiet-logger.js

@@ -0,0 +1,52 @@
+/**
+ * The loggers the Slack libraries are given, so that none of their text reaches the log.
+ *
+ * Read in `@slack/web-api` 8.2.0, `@slack/socket-mode` 3.1.0 and `@slack/bolt` 5.1.0 (`dist/`):
+ * with no `logger` option each builds a console logger of its own, which writes to standard
+ * output and standard error, outside `src/log.ts`. Their lines carry text the daemon withholds
+ * elsewhere (`describeRefusal` keeps Slack's sentence out because it can quote a value of the
+ * message): every `[ERROR]` and `[WARN]` entry of a refusal's `response_metadata.messages`, the
+ * failure message of a request, `${error}` of an error Bolt's receiver reports. At the debug
+ * level they also write each request body and each result, which hold the message text and, for
+ * `apps.connections.open`, the WebSocket URL with its ticket; Bolt's `processEvent` does the
+ * same with the whole event, in developer mode only.
+ *
+ * A custom `logger` replaces the library's own and its `logLevel` is then ignored, so the
+ * debug text is never forwarded here either. A failure the libraries report this way also
+ * reaches the code that called them, as a typed error the daemon logs by its name
+ * (`describe` in `reply/errors.ts`), or, for a Socket Mode connection that cannot come back, as
+ * the unhandled rejection that stops the daemon (`main.ts`).
+ */
+import { LogLevel } from "@slack/web-api";
+import { getLogger } from "../../log.js";
+export const logger = getLogger("allaboard.chat.slack.libraries");
+function quiet(write) {
+    return {
+        debug: () => { },
+        info: () => { },
+        warn: () => write("warning"),
+        error: () => write("error"),
+        setLevel: () => { },
+        // Warn: a library that asks builds no debug string (Socket Mode's `ack` JSON-encodes its
+        // answer only at the debug level).
+        getLevel: () => LogLevel.WARN,
+        setName: () => { },
+    };
+}
+/** Writes nothing, at any level: the web clients, whose failures come back as typed errors. */
+export function silentLogger() {
+    return quiet(() => { });
+}
+/**
+ * Writes one line per warning or error the library reports, naming the library and the level and
+ * nothing the library said: Bolt's app and its Socket Mode receiver, whose lines name no method
+ * and no id the daemon could add to.
+ */
+export function levelLogger(library) {
+    return quiet((level) => {
+        if (level === "error")
+            logger.error(`${library} reported an error`);
+        else
+            logger.warning(`${library} reported a warning`);
+    });
+}