allaboard 0.0.0-stage → 0.4.0

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

@@ -0,0 +1,482 @@
+/**
+ * The clicks and forms that answer the questions the daemon puts to the owner, as Slack sends
+ * them: a tool's permission request and the agent's own questions, the same-folder hold and the
+ * session setup. What is asked, which choices exist and what follows an answer are the core's
+ * (`core/flows/`); each listener checks the owner and the channel, reads its payload and tells
+ * the core through `ChatInbound.answer`. The controls that only redraw a message stay here.
+ */
+import { fill, texts } from "../../../core/port.js";
+import { HOLD_CONTINUE } from "../hold.js";
+import { describe } from "../reply/errors.js";
+import { APPROVAL_ALLOW, absorb, draftAnswers, firstIncomplete, isAnswered, loadIds, newDraft, QUESTION_EDIT, QUESTION_FORM, QUESTION_SKIP, questionView, refusedView, } from "../requests.js";
+import { readChoice, readSelection, setupBlocks } from "../setup.js";
+import * as slackTexts from "../texts.js";
+import { isCancelled, logger } from "./answers.js";
+import { interactionActor, isOwner } from "./guards.js";
+import { clickThread, firstAction, messageTs, record, str, text, } from "./wire.js";
+/** The block ids of the input blocks in `blocks`, in order; none for anything but a list. */
+function inputIds(blocks) {
+    if (!Array.isArray(blocks))
+        return [];
+    return blocks.flatMap((block) => {
+        const entry = record(block);
+        return entry.type === "input" ? [str(entry.block_id)] : [];
+    });
+}
+export class Requests {
+    parts;
+    answers;
+    /**
+     * What the owner filled in each open question form, by request id: kept here, not in the
+     * view's `private_metadata` (which holds the request's ids, the form's generation and its
+     * page), so Other and Notes are bound by no
+     * Slack limit and Answer reopens a closed form with the answers kept. An entry goes when its
+     * request is answered, skipped or found gone, at the next Answer for any request that ended
+     * another way, and when the app closes.
+     */
+    drafts = new Map();
+    constructor(parts, answers) {
+        this.parts = parts;
+        this.answers = answers;
+    }
+    /** Drops the drafts of requests that no longer wait for an answer. */
+    sweep() {
+        for (const [approvalId, draft] of this.drafts) {
+            if (this.parts.approvals.questions(approvalId, draft.channelId, draft.threadTs) === null) {
+                this.drafts.delete(approvalId);
+            }
+        }
+    }
+    /** Gives up the drafts: the daemon is stopping. */
+    close() {
+        this.drafts.clear();
+    }
+    // Issue #142: the facts that tell apart the paths that answer `texts.HOLD_GONE`, for the click
+    // that only redraws (a model picked); the core logs those of the answers it refuses. Ids and
+    // flags only: the click's text and the setup's choice never reach the log.
+    logRefusedClick(path, body, facts) {
+        const told = Object.entries(facts)
+            .map(([name, value]) => `${name}=${value ? "True" : "False"}`)
+            .join(", ");
+        logger.info(`refused a click (${path}): action ${str(firstAction(body).action_id)} in ` +
+            `${str(record(body.channel).id)}/${clickThread(body)} on message ` +
+            `${str(record(body.message).ts)}; ${told}`);
+    }
+    /** Send anyway, or Don't send: the two buttons of the same-folder hold. */
+    onHoldDecision = async (ack, body) => {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        const action = firstAction(body);
+        await this.parts.inbound.answer({ channel, thread: threadTs }, str(action.value), { type: "hold", send: action.action_id === HOLD_CONTINUE }, 
+        // A click that names no message is still answered: nothing is removed for it.
+        text(record(body.message).ts));
+    };
+    /** Start, in a session's setup: the controls as they stand ride on the click. */
+    onSetupStart = async (ack, body) => {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        await this.parts.inbound.answer({ channel, thread: threadTs }, str(firstAction(body).value), { type: "setup", selection: readSelection(record(body.state).values) }, text(record(body.message).ts));
+    };
+    /**
+     * A new model changes which efforts exist: the message is rewritten with the levels of the
+     * model now chosen, keeping the rest. An edit never rings a phone.
+     */
+    onSetupModel = async (ack, body) => {
+        await ack();
+        const { holds, limiter, slack } = this.parts;
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        const shownAt = messageTs(body);
+        const setupId = holds.atMessage(channel, threadTs, shownAt);
+        if (setupId === null && holds.decidedAt(channel, threadTs, shownAt)) {
+            // Picked just before Start and handled once Start decided the setup (issue #142): what
+            // ends the apply (the summary, `Not sent.` or the error) says what happened.
+            this.logRefusedClick("setup model, decided", body, { open_at_message: false, held: true });
+            return;
+        }
+        if (setupId === null) {
+            this.logRefusedClick("setup model, no open setup", body, {
+                open_at_message: false,
+                held: false,
+            });
+            await this.answers.tellOwner(channel, threadTs, texts.HOLD_GONE);
+            return;
+        }
+        const draw = this.parts.chat.drawnSetup(setupId);
+        if (draw === undefined) {
+            // Not kept (a long-forgotten request): the controls keep what they showed.
+            this.logRefusedClick("setup model, draw not kept", body, { open_at_message: true });
+            return;
+        }
+        const choice = readChoice(record(body.state).values, draw.models);
+        try {
+            await limiter.acquire();
+            // The wait above can outlast Start: a decided setup now shows its summary, which this
+            // edit must not overwrite.
+            if (holds.atMessage(channel, threadTs, shownAt) !== setupId || this.answers.stopped)
+                return;
+            await slack.chat.update({
+                channel,
+                ts: shownAt,
+                text: texts.SETUP_FALLBACK,
+                blocks: setupBlocks(setupId, draw, choice),
+            });
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            // The controls keep what they showed; Start still reads the model and the effort.
+            logger.warning(`could not update a setup message in ${channel}: ${describe(error)}`);
+        }
+    };
+    /** An effort or bypass change needs nothing: Start reads every control's state. */
+    onSetupEdit = async (ack) => {
+        await ack();
+    };
+    /** Approve, Deny or Skip on a request of the agent's. */
+    onDecision = async (ack, body) => {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        const action = firstAction(body);
+        const answer = action.action_id === QUESTION_SKIP
+            ? { type: "question", answers: null, notes: {} }
+            : { type: "permission", allow: action.action_id === APPROVAL_ALLOW };
+        if (action.action_id === QUESTION_SKIP)
+            this.drafts.delete(str(action.value));
+        await this.parts.inbound.answer({ channel, thread: threadTs }, str(action.value), answer, text(record(body.message).ts));
+    };
+    /**
+     * A change in the question form, dispatched by Slack with the form's state (block reference,
+     * input block `dispatch_action` and `dispatch_action_config`; block_actions payload reference;
+     * `views.update`, all read 2026-10-16). Every field reports, so the draft holds what is on
+     * screen when the form is closed with Close. Only a change of the choice redraws, with Other's
+     * field and Notes as the new choice needs them, in one `views.update`; typing never does. `hash`
+     * makes a stale payload a `hash_conflict`, which is ignored. Submit reads the state again. Only
+     * the newest form of a request counts (`Draft.generation`) and only the page it shows now
+     * (`FormIds`); anything else is ignored.
+     */
+    onQuestionLive = async (ack, body, redraw) => {
+        await ack();
+        const { approvals, identity, slack } = this.parts;
+        const [user, team] = interactionActor(body);
+        // (sync) The owner and the workspace, as on Next; the channel is checked at Submit.
+        if (!isOwner(identity, user, team)) {
+            logger.info("ignored an inbound event from someone other than the owner");
+            return;
+        }
+        const view = record(body.view);
+        if (view.callback_id !== QUESTION_FORM)
+            return;
+        let ids;
+        try {
+            ids = loadIds(str(view.private_metadata));
+        }
+        catch {
+            return;
+        }
+        const questions = approvals.questions(ids.approvalId, ids.channelId, ids.threadTs);
+        if (questions === null) {
+            this.drafts.delete(ids.approvalId);
+            return;
+        }
+        // Only the newest form of the request counts, and only the page it shows now: a late change
+        // from an older form, or from a page Next has left, writes nothing.
+        const kept = this.drafts.get(ids.approvalId);
+        if (kept === undefined || kept.generation !== ids.generation || kept.active !== ids.active) {
+            return;
+        }
+        // (sync) Kept before any await: a payload handled next finds what this one saw.
+        const draft = absorb(kept, record(view.state).values);
+        this.drafts.set(ids.approvalId, draft);
+        const viewId = text(view.id);
+        if (!redraw || viewId === null || this.answers.stopped)
+            return;
+        const hash = text(view.hash);
+        try {
+            await slack.views.update({
+                view_id: viewId,
+                ...(hash === null ? {} : { hash }),
+                view: questionView(draft, questions, this.parts.names),
+            });
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            // hash_conflict (a newer payload moved the form on) or not_found (closed): Submit reads
+            // the state as it stands.
+            logger.warning(`could not update the question form: ${describe(error)}`);
+        }
+    };
+    /** An option picked, or a box ticked, in the question form: the form is drawn again. */
+    onQuestionChoice = (ack, body) => this.onQuestionLive(ack, body, true);
+    /** A character typed under Other or in Notes in the question form: the draft alone changes. */
+    onQuestionTyping = (ack, body) => this.onQuestionLive(ack, body, false);
+    /**
+     * Edit, on the review page of the question form: that question's page, with its answers as
+     * stored (`views.update` with the payload's view id and hash, block_actions payload and
+     * `views.update` references, read 2026-10-16). The review page has no field, so nothing is
+     * absorbed or validated. It checks the owner and the workspace like any inbound path, follows
+     * the newest-form rule of `onQuestionLive`, acts only from the review page and never reaches
+     * the core. The draft's page moves before the call so that a late change from the page left is
+     * ignored; when Slack refuses the update (`hash_conflict`: the form moved on, `not_found`: it
+     * closed) the draft is put back, unless Submit answers sent it meanwhile.
+     */
+    onQuestionEdit = async (ack, body) => {
+        await ack();
+        const { approvals, identity, slack } = this.parts;
+        const [user, team] = interactionActor(body);
+        // (sync) The owner and the workspace, as on Next; the channel is checked at Submit.
+        if (!isOwner(identity, user, team)) {
+            logger.info("ignored an inbound event from someone other than the owner");
+            return;
+        }
+        const view = record(body.view);
+        if (view.callback_id !== QUESTION_FORM)
+            return;
+        let ids;
+        try {
+            ids = loadIds(str(view.private_metadata));
+        }
+        catch {
+            return;
+        }
+        const questions = approvals.questions(ids.approvalId, ids.channelId, ids.threadTs);
+        if (questions === null) {
+            this.drafts.delete(ids.approvalId);
+            return;
+        }
+        const target = Number(QUESTION_EDIT.exec(str(firstAction(body).action_id))?.[1] ?? Number.NaN);
+        const kept = this.drafts.get(ids.approvalId);
+        if (kept === undefined ||
+            kept.generation !== ids.generation ||
+            kept.active !== ids.active ||
+            questions.length < 2 ||
+            ids.active !== questions.length ||
+            !Number.isInteger(target) ||
+            target >= questions.length) {
+            return;
+        }
+        // (sync) Kept before any await: a payload handled next finds what this one saw.
+        const moved = { ...kept, active: target };
+        this.drafts.set(ids.approvalId, moved);
+        const viewId = text(view.id);
+        if (viewId === null || this.answers.stopped)
+            return;
+        const hash = text(view.hash);
+        try {
+            await slack.views.update({
+                view_id: viewId,
+                ...(hash === null ? {} : { hash }),
+                view: questionView(moved, questions, this.parts.names),
+            });
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            // The form on screen is still the review page.
+            if (this.drafts.get(ids.approvalId) === moved)
+                this.drafts.set(ids.approvalId, kept);
+            logger.warning(`could not open a question from the review page: ${describe(error)}`);
+        }
+    };
+    /**
+     * Answer, on a question of Claude's: opens the form, then checks the channel. The form shows
+     * the owner alone what the request already shows, and Submit checks the channel again before
+     * anything reaches the agent; a refused channel turns the open form into the reason.
+     */
+    onQuestionOpen = async (ack, body) => {
+        await ack();
+        const { approvals, guard, names, slack } = this.parts;
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!this.answers.fromOwner(user, team, channel) || channel === null)
+            return;
+        const approvalId = str(firstAction(body).value);
+        const questions = approvals.questions(approvalId, channel, threadTs);
+        this.sweep();
+        if (questions === null) {
+            await this.answers.tellOwner(channel, threadTs, texts.APPROVAL_GONE);
+            return;
+        }
+        // A form closed with Close and opened again shows what was given, on the page it was left
+        // on. Every Answer opens a new generation, and the older forms of the request go stale.
+        const kept = this.drafts.get(approvalId) ?? newDraft(approvalId, channel, threadTs);
+        const draft = { ...kept, generation: kept.generation + 1 };
+        this.drafts.set(approvalId, draft);
+        // trigger_id lives 3 seconds: no network call before this one (#325).
+        const view = questionView(draft, questions, names);
+        let opened;
+        try {
+            const trigger = text(body.trigger_id);
+            if (trigger === null)
+                throw new TypeError("the click carries no trigger_id");
+            const answer = await slack.views.open({
+                trigger_id: trigger,
+                view: view,
+            });
+            opened = answer.view;
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            // an expired trigger_id, say: the turn must not wait unseen. The form did not open, so
+            // the one still on screen stays the valid one.
+            if (this.drafts.get(approvalId) === draft)
+                this.drafts.set(approvalId, kept);
+            const message = fill(slackTexts.QUESTION_NOT_OPENED, { error: describe(error) });
+            await this.answers.tellOwner(channel, threadTs, message);
+            return;
+        }
+        if (this.answers.stopped)
+            return;
+        const reason = await guard.refusal(channel);
+        if (this.answers.stopped || reason === null)
+            return;
+        const told = fill(slackTexts.CHANNEL_REFUSED, { reason });
+        try {
+            if (opened?.id === undefined)
+                throw new TypeError("views.open answered no view id");
+            // The hash it was opened with: a Next clicked meanwhile is not overwritten.
+            await slack.views.update({
+                view_id: opened.id,
+                ...(opened.hash === undefined ? {} : { hash: opened.hash }),
+                view: refusedView(told, names),
+            });
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            // Closed, or moved on: Submit refuses it, and the owner learns why here.
+            logger.warning(`could not show the refusal in the question form: ${describe(error)}`);
+            await this.answers.tellOwner(channel, threadTs, told);
+        }
+    };
+    /**
+     * Next, Review or Submit, in the question form. Slack wants the answer within 3 seconds, and a missing
+     * answer can only be shown in it: the checks before it make no network call. The channel is
+     * checked before acting.
+     */
+    onQuestionSubmit = async (ack, body) => {
+        const { approvals, identity } = this.parts;
+        const [user, team] = interactionActor(body);
+        const view = record(body.view);
+        let ids;
+        try {
+            ids = loadIds(str(view.private_metadata));
+        }
+        catch {
+            await ack();
+            return;
+        }
+        if (!isOwner(identity, user, team)) {
+            await ack();
+            logger.info("ignored an inbound event from someone other than the owner");
+            return;
+        }
+        const questions = approvals.questions(ids.approvalId, ids.channelId, ids.threadTs);
+        if (questions === null) {
+            this.drafts.delete(ids.approvalId);
+            await ack();
+            await this.answers.tellOwner(ids.channelId, ids.threadTs, texts.APPROVAL_GONE);
+            return;
+        }
+        const state = record(view.state).values;
+        // The page after the last question lists the answers (only a form of several has one).
+        const reviewing = questions.length > 1 && ids.active === questions.length;
+        const kept = this.drafts.get(ids.approvalId);
+        if (kept === undefined || kept.generation !== ids.generation) {
+            // An older form: it sends nothing, and the newest one is told apart from it. The review
+            // page has no field to carry an error, so it is replaced by the reason.
+            if (reviewing) {
+                await ack({
+                    response_action: "update",
+                    view: refusedView(slackTexts.QUESTION_STALE, this.parts.names),
+                });
+                return;
+            }
+            await ack({
+                response_action: "errors",
+                errors: { [`q${ids.active}`]: slackTexts.QUESTION_STALE },
+            });
+            return;
+        }
+        const at = ids.active;
+        // The review page has no field: its draft is the one kept.
+        const draft = reviewing ? { ...kept, active: at } : absorb({ ...kept, active: at }, state);
+        this.drafts.set(ids.approvalId, draft);
+        if (!reviewing) {
+            // A redraw Slack refused (`hash_conflict`) or one that has not landed yet leaves the form
+            // other than the draft draws; `view.blocks` of the payload lists the blocks on screen
+            // (docs.slack.dev, view interactions payload, read 2026-10-16: it does not say whether an
+            // empty input is listed in the state, so the state is not used for this). Only two
+            // differences put an answer at risk: Other chosen with no field to type in (Slack's
+            // required check could not run), and a note in the draft whose field the owner cannot
+            // see, though the form draws one. Any other difference sends what the draft holds: a
+            // field left on screen is read by `absorb`, and its text is used only while its choice is.
+            const drawn = questionView(draft, questions, this.parts.names);
+            const shown = inputIds(view.blocks);
+            const hidesOther = draft.other.has(at) && !shown.includes(`o${at}`);
+            const hidesNote = draft.notes.has(at) &&
+                inputIds(drawn.blocks).includes(`n${at}`) &&
+                !shown.includes(`n${at}`);
+            if (hidesOther || hidesNote) {
+                await ack({ response_action: "update", view: drawn });
+                return;
+            }
+            if (!isAnswered(draft, questions, at)) {
+                // Spaces alone in Other's field are empty once stripped, and Slack keeps them there.
+                const field = draft.other.has(at) ? `o${at}` : `q${at}`;
+                await ack({
+                    response_action: "errors",
+                    errors: { [field]: slackTexts.QUESTION_MISSING },
+                });
+                return;
+            }
+        }
+        // A form of several questions sends from its review page alone; every other page moves on.
+        // Before the review was reached Next goes to the next page; on the last page, and on every
+        // page once the review was reached, Review goes to it, or to the first question with no
+        // answer, which shows no error text.
+        const sends = reviewing || questions.length === 1;
+        const missing = sends ? firstIncomplete(draft, questions) : null;
+        if (!sends || missing !== null) {
+            const toReview = questions.length > 1 && !reviewing && (draft.reviewed || at === questions.length - 1);
+            // `missing` is set only when the draft changed under the review page or a one-question
+            // form; kept so that a draft cannot reach the agent incomplete.
+            const to = missing ?? (toReview ? (firstIncomplete(draft, questions) ?? questions.length) : at + 1);
+            const next = { ...draft, active: to, reviewed: draft.reviewed || to === questions.length };
+            this.drafts.set(ids.approvalId, next);
+            await ack({
+                response_action: "update",
+                view: questionView(next, questions, this.parts.names),
+            });
+            return;
+        }
+        await ack();
+        if (!(await this.answers.admitted(user, team, ids.channelId, ids.threadTs)))
+            return;
+        const given = draftAnswers(draft, questions);
+        if (given === null)
+            throw new Error("a draft with every question answered has no answers");
+        this.drafts.delete(ids.approvalId);
+        // The form is no message of the thread: the session that asked decides what becomes of the
+        // request message (`ThreadSession` keeps the answers in the reply, or in the request).
+        await this.parts.inbound.answer({ channel: ids.channelId, thread: ids.threadTs }, ids.approvalId, { type: "question", ...given }, null);
+    };
+}

package/dist/chat/slack/app/resume-bind.js

@@ -0,0 +1,71 @@
+/**
+ * `!bind`, `!resume` and the offer of `!allaboard update`, typed or clicked, as the Slack provider
+ * hears them. What is offered,
+ * which rows a list holds and what follows a pick are the core's (`src/core/flows/lists.ts`);
+ * here a click is acknowledged, checked for the owner and the channel, and read into the pick
+ * the core is told of. The lists themselves are drawn by `SlackChannel.offer`.
+ */
+import { parseResumeValue } from "../resume.js";
+import { interactionActor } from "./guards.js";
+import { clickThread, firstAction, messageTs, record, str, text, } from "./wire.js";
+export class ResumeBind {
+    parts;
+    answers;
+    constructor(parts, answers) {
+        this.parts = parts;
+        this.answers = answers;
+    }
+    /** A Bind button of the folder list. */
+    onBind = async (ack, body) => {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        // The button is not trusted: the core checks its folder as it checks a typed `!bind`.
+        await this.parts.inbound.picked({
+            type: "folder",
+            channel,
+            path: str(firstAction(body).value),
+            list: messageTs(body),
+        });
+    };
+    /** A Resume button of the session list. */
+    onResume = async (ack, body) => {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        // A value of another shape is a list posted before the button carried its thread: the core
+        // is told the button named none. The session and the thread are checked again by the core.
+        const value = str(firstAction(body).value);
+        const parsed = parseResumeValue(value);
+        await this.parts.inbound.picked({
+            type: "session",
+            channel,
+            sessionId: parsed === null ? value : parsed[0],
+            thread: parsed === null ? null : { channel, thread: parsed[1] },
+            list: messageTs(body),
+        });
+    };
+    /** The Update button of the offer `!allaboard update` posted in a channel. */
+    onUpdate = async (ack, body) => {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null)
+            return;
+        // The version is the button's value, untrusted: the core installs it only when it is newer
+        // than the one that runs and the copy and the service allow it.
+        await this.parts.inbound.picked({
+            type: "update",
+            channel,
+            version: str(firstAction(body).value),
+            list: messageTs(body),
+        });
+    };
+}

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

@@ -0,0 +1,83 @@
+/** The object a field holds, or an empty one for anything else. */
+export function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+/** The string a field holds; null for a missing one and for any other type. */
+export function text(value) {
+    return typeof value === "string" ? value : null;
+}
+/** The list a field holds, or an empty one. */
+export function items(value) {
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * Python's `str(value)` for what a payload holds: a missing field reads `None`, which names no
+ * message, thread or request.
+ */
+export function str(value) {
+    if (value === undefined || value === null)
+        return "None";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    if (typeof value === "number" || typeof value === "bigint")
+        return String(value);
+    return JSON.stringify(value);
+}
+/** Whether a parsed JSON value is present: empty and zero are not. */
+function truthy(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === "object")
+        return Object.keys(value).length > 0;
+    return Boolean(value);
+}
+/** The first action of a click: `body["actions"][0]`, empty when the payload carries none. */
+export function firstAction(body) {
+    return record(items(body.actions)[0]);
+}
+/**
+ * The ts of the message a button sits on: a click that names none throws, and the listener's
+ * failure is logged.
+ */
+export function messageTs(body) {
+    const message = body.message;
+    if (typeof message !== "object" || message === null || !("ts" in message)) {
+        throw new TypeError("the click names no message");
+    }
+    return str(message.ts);
+}
+/**
+ * The thread a button or a form sits in: `container.thread_ts`, falling back to
+ * `message.thread_ts` then the message's own ts (a button is never trusted, so the thread it
+ * answers in is read the same way for every kind of click).
+ */
+export function clickThread(body) {
+    const container = record(body.container);
+    const message = record(body.message);
+    const found = [container.thread_ts, message.thread_ts].find(truthy);
+    return str(found === undefined ? message.ts : found);
+}
+/**
+ * When an interaction happened, from its `action_ts`: what orders the updates it causes. `now`,
+ * the arrival time in seconds, for a payload that carries none.
+ *
+ * `inf`, `nan` and digits grouped with `_`, which Slack never writes, are a payload that carries
+ * no time.
+ */
+export function actionKey(action, now) {
+    const raw = action.action_ts;
+    if (typeof raw === "number" && Number.isFinite(raw))
+        return raw;
+    if (typeof raw === "string" && raw.trim() !== "") {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return now();
+}