toolroll 0.9.17 → 0.9.18

package/dist/slack-chat.js

@@ -1,4 +1,5 @@
 import { chatFlowButtons } from "./chat-flow.js";
+import { refuseResultShots, resultShotsPruned } from "./result-shots.js";
 import { chatQuestionButtons } from "./teammate-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { channelInbox } from "./chat-inbox.js";
@@ -232,6 +233,13 @@ export async function deliverSlackPart(options) {
         if (content.task &&
             !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
             throw new SlackError("Connected projects changed");
+        // A screenshot sent with a result goes in that result's thread once its message is placed.
+        const follows = content.shot?.follows == null ? undefined : state.db.prepare("SELECT message FROM slack_part WHERE id=? AND state='sent'").get(content.shot.follows)?.message;
+        const thread = slackTs(follows) ? String(follows) : event.thread;
+        if (content.image && content.shot && resultShotsPruned(options.evidenceRoot, content.image.run)) {
+            state.db.prepare("UPDATE slack_part SET state='dropped',problem='Removed by retention' WHERE id=?").run(row.id);
+            return true;
+        }
         if (content.image) {
             const verified = verifyResultImage(store, options.evidenceRoot, repos, content.image);
             if (!verified.ok) {
@@ -272,7 +280,7 @@ export async function deliverSlackPart(options) {
                         : [];
                     const found = receipts
                         .map(object)
-                        .find((receipt) => receipt.thread_ts === event.thread && slackTs(receipt.ts));
+                        .find((receipt) => (receipt.thread_ts ?? "") === thread && slackTs(receipt.ts));
                     if (found) {
                         state.db
                             .prepare("UPDATE slack_part SET state='sent',message=?,problem=NULL WHERE id=?")
@@ -288,7 +296,7 @@ export async function deliverSlackPart(options) {
                         },
                     ],
                     channel_id: destination,
-                    thread_ts: event.thread,
+                    thread_ts: thread === "" ? undefined : thread,
                     initial_comment: safeResultImageCaption(content.text, content.image.taskId, content.image.run),
                 });
                 if (!Array.isArray(completed.files) ||
@@ -407,9 +415,9 @@ export async function deliverSlackPart(options) {
             ? await options.api("chat.update", { ...args, ts: target })
             : await options.api("chat.postMessage", {
                 ...args,
-                thread_ts: event.kind === "notice" && event.thread === ""
+                thread_ts: event.kind === "notice" && thread === ""
                     ? undefined
-                    : event.thread,
+                    : thread,
             });
         if (!slackTs(answer.ts) || (target && answer.ts !== target))
             throw new SlackError("Slack did not confirm the message identity", 15_000, true);
@@ -422,6 +430,12 @@ export async function deliverSlackPart(options) {
         return true;
     }
     catch (error) {
+        // No permission to upload files here: one plain line instead of the result's screenshots.
+        const content = JSON.parse(row.payload);
+        if (content.image && content.shot && error instanceof SlackError && ["missing_scope", "no_permission"].includes(error.code)) {
+            refuseResultShots(state, store, row, content, "Slack", nowOf(options));
+            return true;
+        }
         const problem = error instanceof SlackError
             ? error
             : new SlackError("Slack delivery is waiting to retry", 15_000, true);

package/dist/store.d.ts

@@ -47,6 +47,9 @@ export type TaskActRow = {
  * "Something else" is implied. The tapped option comes back as the owner's next message, so nothing here is an answer:
  * a question is open while no later message from the owner sits in its thread. */
 export declare const MATE_ASK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS mate_ask (\n  turn         INTEGER PRIMARY KEY REFERENCES mate_turn(id) ON DELETE CASCADE,\n  thread       INTEGER NOT NULL REFERENCES mate_thread(id) ON DELETE CASCADE,\n  question     TEXT NOT NULL,\n  options_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);\n";
+/** Decisions in the chat app (chat-decide.ts; no version bump: additive only). A token names one act on one card (the chat and message it rides); `digest` is
+ * what the card showed — a receipt, a revision source, a task stamp, a plan or a commit. */
+export declare const CHAT_DECIDE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_decide_action (\n  token       TEXT PRIMARY KEY,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  message     TEXT,\n  act         TEXT NOT NULL CHECK (act IN ('accept','changes','retry','approve','not-now','merge')),\n  phase       TEXT NOT NULL CHECK (phase IN ('offer','yes','cancel')),\n  task_id     TEXT NOT NULL,\n  run         INTEGER,\n  digest      TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_action_message ON chat_decide_action (channel, chat, message);\nCREATE TABLE IF NOT EXISTS chat_decide_prompt (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  task_id     TEXT NOT NULL,\n  run         INTEGER NOT NULL,\n  digest      TEXT NOT NULL,\n  message     TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_prompt_open ON chat_decide_prompt (channel, binding, consumed_at);\n";
 export type MateAsk = {
     turn: number;
     thread: number;
@@ -992,12 +995,18 @@ export type TelegramDelivery = Notification & {
 };
 /** How chats reach one person (quiet chat): only when they are needed, or every step. */
 export type NotificationMode = "quiet" | "all";
+/** Screenshots with results: none (the default), the first one, or up to four (result-shots.ts). */
+export type ResultScreenshots = "off" | "first" | "all";
+export declare const RESULT_SCREENSHOTS: readonly ResultScreenshots[];
 export type NotificationPreference = {
     mode: NotificationMode;
     digestAt: string | null;
     digestOn: string | null;
     updatedAt: string | null;
+    screenshots: ResultScreenshots;
 };
+/** One person's saved screenshots following a result message: its own outbox row, addressed to them (result-shots.ts). */
+export declare const RESULT_SHOTS_KIND = "result-screenshots";
 /** Tasks filed this close together share one chat message. */
 export declare const QUIET_GROUP_MS = 60000;
 export declare function isDigestTime(value: string): boolean;
@@ -7495,7 +7504,20 @@ export declare class Store {
     setNotificationPreference(account: string, change: {
         mode?: NotificationMode;
         digestAt?: string | null;
+        screenshots?: ResultScreenshots;
     }, by: string, now: Date): NotificationPreference;
+    /** The screenshots of this result already sent (or being sent) to one destination. */
+    resultShotsSent(destination: string, run: number): Set<number>;
+    /** Mark screenshots as sent BEFORE they go: an unconfirmed send is never repeated. */
+    markResultShotsSent(destination: string, run: number, artifacts: readonly number[], now: Date): void;
+    /** Telegram refused them outright, so nothing arrived: they may be tried again. */
+    unmarkResultShotsSent(destination: string, run: number, artifacts: readonly number[]): void;
+    /**
+     * A result message just became a fact: everyone who asked for screenshots with results, can see the project and
+     * would be pinged by it gets one row of their own that follows it — once per result, whatever produced the fact.
+     * Only a result that saved screenshots qualifies; what is sent, and whether at all, is decided again at send time.
+     */
+    private enqueueResultShots;
     /** Everyone who asked for an evening digest, with the local day theirs was last considered. */
     eveningDigestPeople(): {
         account: string;
@@ -7588,6 +7610,8 @@ export declare class Store {
     chatBatchFor(destination: string, taskRef: number, run: number | null, now: Date, windowMs: number, notification?: number | null): ChatBatch;
     chatBatch(id: number): ChatBatch | null;
     setChatBatchMessage(id: number, message: string, digest: string): void;
+    /** The finished-work message that carries this result at one destination, if one was placed: screenshots follow it. */
+    chatBatchMessageFor(destination: string, taskRef: number, run: number): string | null;
     /** The message now showing this card, and what it shows. */
     setChatCardMessage(id: number, message: string, digest: string): void;
     markTelegramDigestSent(now: Date): void;

package/dist/store.js

@@ -148,7 +148,8 @@ CREATE TABLE IF NOT EXISTS notification_preference (
   digest_at  TEXT CHECK (digest_at IS NULL OR (length(digest_at) = 5 AND digest_at GLOB '[0-2][0-9]:[0-5][0-9]')),
   digest_on  TEXT,
   updated_at TEXT NOT NULL,
-  updated_by TEXT NOT NULL
+  updated_by TEXT NOT NULL,
+  screenshots TEXT NOT NULL DEFAULT 'off' CHECK (screenshots IN ('off', 'first', 'all'))
 );
 CREATE TABLE IF NOT EXISTS chat_card (
   id          INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -183,6 +184,18 @@ CREATE TABLE IF NOT EXISTS chat_batch_item (
   PRIMARY KEY (batch, task_ref)
 );
 `;
+/** Screenshots with results (no version bump: additive only): each saved screenshot a destination was sent with a
+ * result, marked before the upload so a retry never sends it twice. No foreign keys: a deleted project's runs take
+ * their rows with them (project-delete.ts). */
+const RESULT_SHOT_SCHEMA = `
+CREATE TABLE IF NOT EXISTS result_shot_sent (
+  destination TEXT NOT NULL,
+  run         INTEGER NOT NULL,
+  artifact    INTEGER NOT NULL,
+  sent_at     TEXT NOT NULL,
+  PRIMARY KEY (destination, run, artifact)
+);
+`;
 /** Settings → Lead (no version bump: additive only): what one person calls their lead and the short persona it
  * speaks with, and what their lead knows about them (`about_json`: the confirmed lines, lead-about.ts). No row reads
  * as the defaults (lead-identity.ts). */
@@ -295,6 +308,40 @@ CREATE TABLE IF NOT EXISTS mate_ask (
 );
 CREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);
 `;
+/** Decisions in the chat app (chat-decide.ts; no version bump: additive only). A token names one act on one card (the chat and message it rides); `digest` is
+ * what the card showed — a receipt, a revision source, a task stamp, a plan or a commit. */
+export const CHAT_DECIDE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS chat_decide_action (
+  token       TEXT PRIMARY KEY,
+  channel     TEXT NOT NULL,
+  binding     INTEGER NOT NULL,
+  chat        TEXT NOT NULL,
+  message     TEXT,
+  act         TEXT NOT NULL CHECK (act IN ('accept','changes','retry','approve','not-now','merge')),
+  phase       TEXT NOT NULL CHECK (phase IN ('offer','yes','cancel')),
+  task_id     TEXT NOT NULL,
+  run         INTEGER,
+  digest      TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  expires_at  TEXT NOT NULL,
+  consumed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS chat_decide_action_message ON chat_decide_action (channel, chat, message);
+CREATE TABLE IF NOT EXISTS chat_decide_prompt (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  channel     TEXT NOT NULL,
+  binding     INTEGER NOT NULL,
+  chat        TEXT NOT NULL,
+  task_id     TEXT NOT NULL,
+  run         INTEGER NOT NULL,
+  digest      TEXT NOT NULL,
+  message     TEXT,
+  created_at  TEXT NOT NULL,
+  expires_at  TEXT NOT NULL,
+  consumed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS chat_decide_prompt_open ON chat_decide_prompt (channel, binding, consumed_at);
+`;
 export const MATE_ASK_OTHER = "Something else";
 /** How long the question's buttons work, on every channel. */
 export const MATE_ASK_TTL_MS = 7 * 86_400_000;
@@ -771,6 +818,9 @@ const LIFECYCLE_HOLD_WORDS = {
     revision: "a plan revision awaiting approval",
     stop: "a stopped attempt that has not been resumed",
 };
+export const RESULT_SCREENSHOTS = ["off", "first", "all"];
+/** One person's saved screenshots following a result message: its own outbox row, addressed to them (result-shots.ts). */
+export const RESULT_SHOTS_KIND = "result-screenshots";
 /** Tasks filed this close together share one chat message. */
 export const QUIET_GROUP_MS = 60_000;
 export function isDigestTime(value) {
@@ -3886,6 +3936,8 @@ function initializeStore(db, file) {
     db.exec(MONITORING_SCHEMA);
     db.exec(INTEGRATIONS_SCHEMA);
     db.exec(MATE_ASK_SCHEMA);
+    // Decisions in the chat app (no version bump: additive only): result, plan and merge buttons, and Request changes.
+    db.exec(CHAT_DECIDE_SCHEMA);
     db.exec(SPEND_SCHEMA);
     // Sign-in pauses: one row per incident of a provider's sign-in no longer working.
     db.exec(PROVIDER_AUTH_SCHEMA);
@@ -3901,6 +3953,9 @@ function initializeStore(db, file) {
     db.exec(POLICY_SCHEMA);
     db.exec(RUN_CHECK_SCHEMA);
     db.exec(QUIET_CHAT_SCHEMA);
+    // Screenshots with results: each person's choice (an older notification_preference gains it), and what was sent.
+    addColumn(db, "notification_preference", "screenshots", "TEXT NOT NULL DEFAULT 'off' CHECK (screenshots IN ('off', 'first', 'all'))");
+    db.exec(RESULT_SHOT_SCHEMA);
     // The update a batch line speaks for: its newest fact about that task (null: a finished result).
     addColumn(db, "chat_batch_item", "notification", "INTEGER");
     db.exec(LEAD_QUIET_SCHEMA);
@@ -15144,6 +15199,11 @@ export class Store {
         if (Number(changes) > 0 && actor !== null) {
             this.db.prepare("INSERT OR IGNORE INTO notification_actor (notification, account, lead) VALUES (?, ?, ?)").run(Number(lastInsertRowid), actor.account, actor.lead ? 1 : 0);
         }
+        if (Number(changes) > 0 && run !== null && notification.recipient == null) {
+            const made = this.notificationById(Number(lastInsertRowid));
+            if (made !== null)
+                this.enqueueResultShots(made, now);
+        }
         return Number(changes) > 0;
     }
     /**
@@ -22228,23 +22288,69 @@ export class Store {
     // ---- quiet chat: each person's notification choice and each task's one message ----
     /** How chats reach this person: only when they are needed unless they chose every step. */
     notificationPreference(account) {
-        const row = this.db.prepare("SELECT mode, digest_at, digest_on, updated_at FROM notification_preference WHERE account = ?").get(account);
-        return row === undefined ? { mode: "quiet", digestAt: null, digestOn: null, updatedAt: null }
+        const row = this.db.prepare("SELECT mode, digest_at, digest_on, updated_at, screenshots FROM notification_preference WHERE account = ?").get(account);
+        return row === undefined ? { mode: "quiet", digestAt: null, digestOn: null, updatedAt: null, screenshots: "off" }
             : { mode: row["mode"] === "all" ? "all" : "quiet", digestAt: row["digest_at"] == null ? null : String(row["digest_at"]),
-                digestOn: row["digest_on"] == null ? null : String(row["digest_on"]), updatedAt: String(row["updated_at"]) };
+                digestOn: row["digest_on"] == null ? null : String(row["digest_on"]), updatedAt: String(row["updated_at"]),
+                screenshots: row["screenshots"] === "first" || row["screenshots"] === "all" ? row["screenshots"] : "off" };
     }
     /** Change one person's choice; a digest time is a local HH:MM, or null for no evening digest. */
     setNotificationPreference(account, change, by, now) {
         if (change.digestAt != null && !isDigestTime(change.digestAt))
             throw new Error("digest time must be HH:MM");
+        if (change.screenshots !== undefined && !RESULT_SCREENSHOTS.includes(change.screenshots))
+            throw new Error("screenshots must be off, first or all");
         const current = this.notificationPreference(account);
         const mode = change.mode ?? current.mode;
         const digestAt = change.digestAt === undefined ? current.digestAt : change.digestAt;
-        this.db.prepare(`INSERT INTO notification_preference (account, mode, digest_at, digest_on, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?)
-      ON CONFLICT (account) DO UPDATE SET mode = excluded.mode, digest_at = excluded.digest_at, updated_at = excluded.updated_at, updated_by = excluded.updated_by`)
-            .run(account, mode, digestAt, current.digestOn, now.toISOString(), by);
+        const screenshots = change.screenshots ?? current.screenshots;
+        this.db.prepare(`INSERT INTO notification_preference (account, mode, digest_at, digest_on, updated_at, updated_by, screenshots) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT (account) DO UPDATE SET mode = excluded.mode, digest_at = excluded.digest_at, updated_at = excluded.updated_at, updated_by = excluded.updated_by,
+        screenshots = excluded.screenshots`)
+            .run(account, mode, digestAt, current.digestOn, now.toISOString(), by, screenshots);
         return this.notificationPreference(account);
     }
+    // ---- screenshots with results (result-shots.ts) ----
+    /** The screenshots of this result already sent (or being sent) to one destination. */
+    resultShotsSent(destination, run) {
+        return new Set(this.db.prepare("SELECT artifact FROM result_shot_sent WHERE destination = ? AND run = ?").all(destination, run).map(row => Number(row["artifact"])));
+    }
+    /** Mark screenshots as sent BEFORE they go: an unconfirmed send is never repeated. */
+    markResultShotsSent(destination, run, artifacts, now) {
+        const insert = this.db.prepare("INSERT OR IGNORE INTO result_shot_sent (destination, run, artifact, sent_at) VALUES (?, ?, ?, ?)");
+        this.transact(() => { for (const artifact of artifacts)
+            insert.run(destination, run, artifact, now.toISOString()); });
+    }
+    /** Telegram refused them outright, so nothing arrived: they may be tried again. */
+    unmarkResultShotsSent(destination, run, artifacts) {
+        const remove = this.db.prepare("DELETE FROM result_shot_sent WHERE destination = ? AND run = ? AND artifact = ?");
+        this.transact(() => { for (const artifact of artifacts)
+            remove.run(destination, run, artifact); });
+    }
+    /**
+     * A result message just became a fact: everyone who asked for screenshots with results, can see the project and
+     * would be pinged by it gets one row of their own that follows it — once per result, whatever produced the fact.
+     * Only a result that saved screenshots qualifies; what is sent, and whether at all, is decided again at send time.
+     */
+    enqueueResultShots(source, now) {
+        if (source.run === null || source.taskRef === null || source.project === null || source.recipient !== null)
+            return;
+        const ready = isLifecycleNotification(source) && source.kind === "run-finished";
+        if (!ready && !/fail/.test(source.kind))
+            return;
+        const run = this.getRun(source.run);
+        if (run === null || !["builder", "repair"].includes(run.role) || run.contestant !== null)
+            return;
+        if (!this.artifactsFor(run.id).some(one => one.kind === "screenshot"))
+            return;
+        const people = this.db.prepare("SELECT account FROM notification_preference WHERE screenshots IN ('first', 'all') ORDER BY account").all().map(row => String(row["account"]));
+        for (const account of people) {
+            if (!this.accountCanAccess(account, source.project) || !this.pingAllowed(source, account))
+                continue;
+            this.enqueueNotification({ dedupeKey: `result-shots:r${run.id}:${account}`, kind: RESULT_SHOTS_KIND, subject: "Screenshots with this result", body: "",
+                ...(source.link === null ? {} : { link: source.link }), source: { run: run.id }, recipient: account }, now);
+        }
+    }
     /** Everyone who asked for an evening digest, with the local day theirs was last considered. */
     eveningDigestPeople() {
         return this.db.prepare("SELECT account, digest_at, digest_on FROM notification_preference WHERE digest_at IS NOT NULL ORDER BY account").all()
@@ -22523,6 +22629,12 @@ export class Store {
     setChatBatchMessage(id, message, digest) {
         this.db.prepare("UPDATE chat_batch SET message = ?, digest = ? WHERE id = ?").run(message, digest, id);
     }
+    /** The finished-work message that carries this result at one destination, if one was placed: screenshots follow it. */
+    chatBatchMessageFor(destination, taskRef, run) {
+        const row = this.db.prepare(`SELECT b.message FROM chat_batch b JOIN chat_batch_item i ON i.batch = b.id
+      WHERE b.destination = ? AND i.task_ref = ? AND (i.run = ? OR i.run IS NULL) AND b.message IS NOT NULL ORDER BY b.id DESC LIMIT 1`).get(destination, taskRef, run);
+        return row === undefined ? null : String(row["message"]);
+    }
     /** The message now showing this card, and what it shows. */
     setChatCardMessage(id, message, digest) {
         this.db.prepare("UPDATE chat_card SET message = ?, digest = ? WHERE id = ?").run(message, digest, id);

package/dist/teams-chat.js

@@ -1,5 +1,6 @@
 /** Microsoft Teams on the shared chat layer: activities in, Adaptive Cards
  * out, the same durable receipts, rooms and commands as every other channel. */
+import { resultShotsPruned } from "./result-shots.js";
 import { chatQuestionButtons } from "./teammate-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { ChatState, chatHash } from "./chat-delivery-state.js";
@@ -175,6 +176,10 @@ export async function deliverTeamsPart(options) {
         if (content.task && !repos.includes(store.lookupRef(content.task)?.repo ?? ""))
             throw new TeamsError("Connected projects changed");
         let text = content.text, actions = [];
+        if (content.image && content.shot && resultShotsPruned(options.evidenceRoot, content.image.run)) {
+            state.prepare("UPDATE chat_part SET state='dropped',problem='Removed by retention' WHERE id=?").run(row.id);
+            return true;
+        }
         if (content.image) {
             text = `${content.text}\n\nScreenshots open from the saved result.`;
             actions = openUrlAction(options.origin(), { label: "Open result", path: chatResultHref(content.image.taskId, content.image.run, "checks") });

package/dist/telegram-mate.d.ts

@@ -28,6 +28,16 @@ export type TelegramConversationOptions = {
      * wires `phoneOrigin` from webhooks.ts; absent, no card carries a link.
      */
     phoneOrigin?: () => string | null;
+    /** Injected by tests: how a Merge tapped in chat reaches GitHub (production: mergePullRequest). */
+    merge?: (input: {
+        runId: number;
+        by: string;
+    }) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
 };
 /** One Bot API call, the shape telegram.ts injects. */
 export type Transport = TelegramTransport;

package/dist/telegram.d.ts

@@ -75,7 +75,9 @@ export declare function scrub(text: string, token: string): string;
  */
 export type TelegramTransport = (method: string, params: Record<string, unknown>, signal?: AbortSignal, 
 /** v64: one verified file to send as multipart — the ONLY way bytes leave. Absent, the call is JSON exactly as before. */
-upload?: TelegramUpload) => Promise<{
+upload?: TelegramUpload, 
+/** More verified files in the same multipart call: the rest of one album (sendMediaGroup). */
+more?: readonly TelegramUpload[]) => Promise<{
     ok: boolean;
     result?: unknown;
     description?: string;
@@ -92,7 +94,7 @@ upload?: TelegramUpload) => Promise<{
  * uploaded by name.
  */
 export type TelegramUpload = {
-    field: "document";
+    field: "document" | "photo" | `shot${number}`;
     fileName: string;
     contentType: "image/png" | "image/jpeg";
     bytes: Buffer;
@@ -113,7 +115,7 @@ export declare function networkFenceLine(reason: string): string;
 /** fetch's own message ("fetch failed") with the reason under it, e.g. "fetch failed (EMFILE: too many open files)". */
 export declare function transportError(error: unknown): string;
 /** The multipart body: every param a field (objects as JSON), the file last. Exported for the adapter's own test only. */
-export declare function multipartOf(params: Record<string, unknown>, upload: TelegramUpload): FormData;
+export declare function multipartOf(params: Record<string, unknown>, upload: TelegramUpload, ...more: readonly TelegramUpload[]): FormData;
 export declare function hashPairingCode(code: string): string;
 /** 128 bits, hex — pasteable, and not guessable inside any code's lifetime. */
 export declare function mintPairingCode(): string;