@pinet/slack-bridge 0.1.0

package/dist/canvases.js

@@ -0,0 +1,221 @@
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+function buildDocumentContent(markdown) {
+    if (markdown == null || markdown.length === 0)
+        return undefined;
+    return { type: "markdown", markdown };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asStringifiedNumber(value) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    return undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.map(asString).filter((item) => Boolean(item));
+    return strings.length > 0 ? strings : undefined;
+}
+export function normalizeSlackCanvasCreateKind(kind) {
+    const normalized = kind?.trim().toLowerCase();
+    if (!normalized)
+        return "standalone";
+    if (normalized === "standalone" || normalized === "channel") {
+        return normalized;
+    }
+    throw new Error("Unsupported canvas kind. Use 'standalone' or 'channel'.");
+}
+export function normalizeSlackCanvasUpdateMode(mode) {
+    const normalized = mode?.trim().toLowerCase();
+    if (!normalized)
+        return "append";
+    if (normalized === "append" || normalized === "prepend" || normalized === "replace") {
+        return normalized;
+    }
+    throw new Error("Unsupported canvas update mode. Use 'append', 'prepend', or 'replace'.");
+}
+export function normalizeSlackCanvasSectionType(type) {
+    const normalized = type?.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "h1" ||
+        normalized === "h2" ||
+        normalized === "h3" ||
+        normalized === "any_header") {
+        return normalized;
+    }
+    throw new Error("Unsupported canvas section type. Use 'h1', 'h2', 'h3', or 'any_header'.");
+}
+export function normalizeSlackCanvasCommentsLimit(limit) {
+    if (limit == null)
+        return 20;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200) {
+        throw new Error("Canvas comment reads require limit to be an integer between 1 and 200.");
+    }
+    return limit;
+}
+export function buildSlackCanvasCreateRequest(input) {
+    const kind = normalizeSlackCanvasCreateKind(input.kind);
+    const channelId = normalizeOptionalString(input.channelId);
+    const title = normalizeOptionalString(input.title);
+    const documentContent = buildDocumentContent(input.markdown);
+    if (kind === "channel") {
+        if (!channelId) {
+            throw new Error("Channel canvases require a channel.");
+        }
+        return {
+            kind,
+            method: "conversations.canvases.create",
+            body: {
+                ...(title ? { title } : {}),
+                ...(documentContent ? { document_content: documentContent } : {}),
+                channel_id: channelId,
+            },
+        };
+    }
+    return {
+        kind,
+        method: "canvases.create",
+        body: {
+            ...(title ? { title } : {}),
+            ...(documentContent ? { document_content: documentContent } : {}),
+            ...(channelId ? { channel_id: channelId } : {}),
+        },
+    };
+}
+export function buildSlackCanvasEditRequest(input) {
+    const canvasId = normalizeOptionalString(input.canvasId);
+    if (!canvasId) {
+        throw new Error("Canvas updates require a canvas ID.");
+    }
+    if (input.markdown.length === 0) {
+        throw new Error("Canvas updates require markdown content.");
+    }
+    const sectionId = normalizeOptionalString(input.sectionId);
+    const mode = normalizeSlackCanvasUpdateMode(input.mode);
+    const operation = mode === "append" ? "insert_at_end" : mode === "prepend" ? "insert_at_start" : "replace";
+    return {
+        canvas_id: canvasId,
+        changes: [
+            {
+                operation,
+                document_content: { type: "markdown", markdown: input.markdown },
+                ...(sectionId ? { section_id: sectionId } : {}),
+            },
+        ],
+    };
+}
+export function buildSlackCanvasSectionsLookupRequest(input) {
+    const canvasId = normalizeOptionalString(input.canvasId);
+    if (!canvasId) {
+        throw new Error("Canvas section lookups require a canvas ID.");
+    }
+    const containsText = normalizeOptionalString(input.containsText);
+    if (!containsText) {
+        throw new Error("Canvas section lookups require text to match.");
+    }
+    const sectionType = normalizeSlackCanvasSectionType(input.sectionType);
+    return {
+        canvas_id: canvasId,
+        criteria: {
+            contains_text: containsText,
+            ...(sectionType ? { section_types: [sectionType] } : {}),
+        },
+    };
+}
+export function pickSlackCanvasSectionId(sections, sectionIndex) {
+    const matches = (sections ?? [])
+        .map((section) => normalizeOptionalString(section.id))
+        .filter((id) => Boolean(id));
+    if (matches.length === 0) {
+        throw new Error("No canvas sections matched the lookup.");
+    }
+    if (sectionIndex != null) {
+        if (!Number.isInteger(sectionIndex) || sectionIndex < 1) {
+            throw new Error("section_index must be a positive integer.");
+        }
+        const selected = matches[sectionIndex - 1];
+        if (!selected) {
+            throw new Error(`Canvas section lookup matched ${matches.length} sections; section_index ${sectionIndex} is out of range.`);
+        }
+        return selected;
+    }
+    if (matches.length > 1) {
+        throw new Error(`Canvas section lookup matched ${matches.length} sections. Provide section_index to choose one result or narrow the lookup.`);
+    }
+    return matches[0];
+}
+export function extractSlackChannelCanvasId(response) {
+    const channel = asRecord(response.channel);
+    const properties = asRecord(channel?.properties);
+    if (!properties)
+        return null;
+    const directCanvas = asString(properties.canvas);
+    if (directCanvas)
+        return directCanvas;
+    const canvasRecord = asRecord(properties.canvas);
+    const canvasId = asString(canvasRecord?.id) ?? asString(canvasRecord?.canvas_id);
+    if (canvasId)
+        return canvasId;
+    const channelSolutions = asRecord(properties.channel_solutions);
+    const canvasIds = asStringArray(channelSolutions?.canvas_ids);
+    if (canvasIds?.[0])
+        return canvasIds[0];
+    return null;
+}
+function extractSlackCanvasCommentText(comment) {
+    return (asString(comment.comment) ??
+        asString(comment.comment_text) ??
+        asString(comment.text) ??
+        asString(comment.plain_text) ??
+        "(no comment text exposed by Slack)");
+}
+export function extractSlackCanvasCommentsPage(response, fallbackCanvasId) {
+    const file = asRecord(response.file) ?? {};
+    const comments = Array.isArray(response.comments)
+        ? response.comments
+        : [];
+    const paging = asRecord(response.paging);
+    const responseMetadata = asRecord(response.response_metadata);
+    const canvasId = asString(file.id) ?? normalizeOptionalString(fallbackCanvasId);
+    if (!canvasId) {
+        throw new Error("Slack did not return a canvas/file id for this canvas comment read.");
+    }
+    const parsedComments = comments.map((comment) => ({
+        ...(asStringifiedNumber(comment.id) ? { id: asStringifiedNumber(comment.id) } : {}),
+        ...(asString(comment.user) ? { userId: asString(comment.user) } : {}),
+        ...(asStringifiedNumber(comment.created ?? comment.timestamp ?? comment.ts)
+            ? { createdTs: asStringifiedNumber(comment.created ?? comment.timestamp ?? comment.ts) }
+            : {}),
+        text: extractSlackCanvasCommentText(comment),
+    }));
+    const nextCursor = asString(responseMetadata?.next_cursor);
+    const totalFromPaging = asNumber(paging?.total);
+    const commentCount = asNumber(file.comments_count) ?? totalFromPaging ?? parsedComments.length;
+    return {
+        canvasId,
+        ...(asString(file.title) ? { title: asString(file.title) } : {}),
+        ...(asString(file.permalink) ? { permalink: asString(file.permalink) } : {}),
+        commentsCount: commentCount,
+        returnedCount: parsedComments.length,
+        ...(asNumber(paging?.page) ? { page: asNumber(paging?.page) } : {}),
+        ...(asNumber(paging?.pages) ? { pages: asNumber(paging?.pages) } : {}),
+        comments: parsedComments,
+        ...(nextCursor ? { nextCursor } : {}),
+    };
+}

package/dist/command-registration-runtime.d.ts

@@ -0,0 +1,9 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type PinetCommandsDeps } from "./pinet-commands.js";
+export interface CommandRegistrationRuntimeDeps {
+    pinetCommands: PinetCommandsDeps;
+}
+export interface CommandRegistrationRuntime {
+    register: (pi: ExtensionAPI) => void;
+}
+export declare function createCommandRegistrationRuntime(deps: CommandRegistrationRuntimeDeps): CommandRegistrationRuntime;

package/dist/command-registration-runtime.js

@@ -0,0 +1,9 @@
+import { registerPinetCommands } from "./pinet-commands.js";
+export function createCommandRegistrationRuntime(deps) {
+    function register(pi) {
+        registerPinetCommands(pi, deps.pinetCommands);
+    }
+    return {
+        register,
+    };
+}

package/dist/core-tool-guardrails.d.ts

@@ -0,0 +1,24 @@
+import { type SecurityGuardrails } from "./guardrails.js";
+export interface SlackToolPolicyTurn {
+    threadTs: string | undefined;
+    threadCount: number;
+}
+export declare const GUARDED_CORE_TOOLS: Set<string>;
+export declare function isGuardedCoreTool(toolName: string): boolean;
+export declare function getGuardrailToolName(toolName: string): string;
+export declare function summarizeCoreToolAction(event: {
+    toolName: string;
+    input: Record<string, unknown>;
+}): string;
+export declare function evaluateSlackOriginCoreToolPolicy(options: {
+    turn: SlackToolPolicyTurn | null;
+    toolName: string;
+    input: Record<string, unknown>;
+    guardrails: SecurityGuardrails;
+    requireToolPolicy: (toolName: string, threadTs: string | undefined, action: string) => void;
+    formatAction: (action: string) => string;
+    formatError: (error: unknown) => string;
+}): {
+    block: true;
+    reason: string;
+} | undefined;

package/dist/core-tool-guardrails.js

@@ -0,0 +1,66 @@
+import { isToolBlocked, toolNeedsConfirmation } from "./guardrails.js";
+export const GUARDED_CORE_TOOLS = new Set(["bash", "read", "edit", "write", "grep", "find", "ls"]);
+export function isGuardedCoreTool(toolName) {
+    return GUARDED_CORE_TOOLS.has(toolName);
+}
+export function getGuardrailToolName(toolName) {
+    return toolName === "grep" ? "rg" : toolName;
+}
+export function summarizeCoreToolAction(event) {
+    const input = event.input;
+    switch (event.toolName) {
+        case "bash":
+            return `command=${String(input.command ?? "")}`;
+        case "read":
+            return `path=${String(input.path ?? "")} | offset=${String(input.offset ?? "")} | limit=${String(input.limit ?? "")}`;
+        case "edit":
+            return `path=${String(input.path ?? "")} | edits=${Array.isArray(input.edits) ? input.edits.length : 0}`;
+        case "write": {
+            const content = typeof input.content === "string" ? input.content : "";
+            return `path=${String(input.path ?? "")} | content_length=${content.length}`;
+        }
+        case "grep":
+            return `pattern=${String(input.pattern ?? "")} | path=${String(input.path ?? "")} | glob=${String(input.glob ?? "")}`;
+        case "find":
+            return `pattern=${String(input.pattern ?? "")} | path=${String(input.path ?? "")} | limit=${String(input.limit ?? "")}`;
+        case "ls":
+            return `path=${String(input.path ?? "")} | limit=${String(input.limit ?? "")}`;
+        default:
+            return JSON.stringify(input);
+    }
+}
+export function evaluateSlackOriginCoreToolPolicy(options) {
+    const { turn, toolName, input, guardrails, requireToolPolicy, formatAction, formatError } = options;
+    if (!turn || !isGuardedCoreTool(toolName)) {
+        return undefined;
+    }
+    const guardrailToolName = getGuardrailToolName(toolName);
+    if (isToolBlocked(guardrailToolName, guardrails)) {
+        return {
+            block: true,
+            reason: `Tool "${guardrailToolName}" is blocked by Slack security guardrails.`,
+        };
+    }
+    if (!toolNeedsConfirmation(guardrailToolName, guardrails)) {
+        return undefined;
+    }
+    const action = summarizeCoreToolAction({ toolName, input });
+    if (!turn.threadTs) {
+        return {
+            block: true,
+            reason: turn.threadCount > 1
+                ? `Tool "${guardrailToolName}" requires Slack confirmation for action ${formatAction(action)}, but this Slack-triggered turn currently batches ${turn.threadCount} threads. Process one Slack thread at a time before using that tool.`
+                : `Tool "${guardrailToolName}" requires Slack confirmation for action ${formatAction(action)}, but there is no tracked Slack thread available for this turn. Retry from a specific Slack thread and call slack with action "confirm_action" there first.`,
+        };
+    }
+    try {
+        requireToolPolicy(guardrailToolName, turn.threadTs, action);
+        return undefined;
+    }
+    catch (error) {
+        return {
+            block: true,
+            reason: formatError(error),
+        };
+    }
+}

package/dist/deploy-manifest.d.ts

@@ -0,0 +1,27 @@
+export interface SlackBridgeSettings {
+    appId?: string;
+    appToken?: string;
+    appConfigToken?: string;
+}
+export interface ManifestScopeChanges {
+    addedBotScopes: string[];
+    removedBotScopes: string[];
+    addedUserScopes: string[];
+    removedUserScopes: string[];
+}
+export interface ResolvedDeployConfig {
+    manifestPath: string;
+    appId?: string;
+    appConfigToken?: string;
+    appToken?: string;
+}
+export interface DeployResult {
+    appId: string;
+    scopeChanges: ManifestScopeChanges;
+}
+export declare function diffManifestScopes(beforeManifest: Record<string, unknown> | null | undefined, afterManifest: Record<string, unknown> | null | undefined): ManifestScopeChanges;
+export declare function formatScopeChangeSummary(changes: ManifestScopeChanges): string[];
+export declare function resolveDeployConfig(settings: SlackBridgeSettings, env: NodeJS.ProcessEnv, cwd?: string): ResolvedDeployConfig;
+export declare function getDeployConfigError(config: ResolvedDeployConfig): string | null;
+export declare function deploySlackManifest(config: ResolvedDeployConfig): Promise<DeployResult>;
+export declare function run(): Promise<void>;

package/dist/deploy-manifest.js

@@ -0,0 +1,197 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
+const execFile = promisify(execFileCallback);
+class SlackMethodError extends Error {
+    method;
+    slackError;
+    details;
+    constructor(method, slackError, details = []) {
+        const detailMessage = details
+            .map((detail) => {
+            const pointer = detail.pointer ? `${detail.pointer}: ` : "";
+            return `- ${pointer}${detail.message ?? "unknown error"}`;
+        })
+            .join("\n");
+        super(detailMessage
+            ? `Slack ${method}: ${slackError}\n${detailMessage}`
+            : `Slack ${method}: ${slackError}`);
+        this.name = "SlackMethodError";
+        this.method = method;
+        this.slackError = slackError;
+        this.details = details;
+    }
+}
+function loadSettings(settingsPath) {
+    const resolvedPath = settingsPath ??
+        path.join(process.env.HOME ?? process.env.USERPROFILE ?? "", ".pi", "agent", "settings.json");
+    try {
+        const content = fs.readFileSync(resolvedPath, "utf-8");
+        const parsed = JSON.parse(content);
+        return (parsed["slack-bridge"] ??
+            {});
+    }
+    catch {
+        return {};
+    }
+}
+function buildSlackRequest(method, token, body) {
+    const headers = {
+        Authorization: `Bearer ${token}`,
+    };
+    let serialized;
+    if (body) {
+        headers["Content-Type"] = "application/json; charset=utf-8";
+        serialized = JSON.stringify(body);
+    }
+    return {
+        url: `https://slack.com/api/${method}`,
+        init: {
+            method: "POST",
+            headers,
+            ...(serialized ? { body: serialized } : {}),
+        },
+    };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readScopeList(manifest, scopeType) {
+    const oauthConfig = asRecord(manifest?.oauth_config);
+    const scopes = asRecord(oauthConfig?.scopes);
+    const raw = scopes?.[scopeType];
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return [
+        ...new Set(raw.filter((item) => typeof item === "string" && item.length > 0)),
+    ].sort();
+}
+export function diffManifestScopes(beforeManifest, afterManifest) {
+    const beforeBot = new Set(readScopeList(beforeManifest, "bot"));
+    const afterBot = new Set(readScopeList(afterManifest, "bot"));
+    const beforeUser = new Set(readScopeList(beforeManifest, "user"));
+    const afterUser = new Set(readScopeList(afterManifest, "user"));
+    const diff = (next, prev) => [...next].filter((scope) => !prev.has(scope)).sort();
+    return {
+        addedBotScopes: diff(afterBot, beforeBot),
+        removedBotScopes: diff(beforeBot, afterBot),
+        addedUserScopes: diff(afterUser, beforeUser),
+        removedUserScopes: diff(beforeUser, afterUser),
+    };
+}
+export function formatScopeChangeSummary(changes) {
+    const lines = [];
+    if (changes.addedBotScopes.length > 0) {
+        lines.push(`Bot scopes added: ${changes.addedBotScopes.join(", ")}`);
+    }
+    if (changes.removedBotScopes.length > 0) {
+        lines.push(`Bot scopes removed: ${changes.removedBotScopes.join(", ")}`);
+    }
+    if (changes.addedUserScopes.length > 0) {
+        lines.push(`User scopes added: ${changes.addedUserScopes.join(", ")}`);
+    }
+    if (changes.removedUserScopes.length > 0) {
+        lines.push(`User scopes removed: ${changes.removedUserScopes.join(", ")}`);
+    }
+    return lines.length > 0 ? lines : ["No scope changes."];
+}
+export function resolveDeployConfig(settings, env, cwd = process.cwd()) {
+    return {
+        manifestPath: path.join(cwd, "slack-bridge", "manifest.yaml"),
+        appId: settings.appId ?? env.SLACK_APP_ID,
+        appConfigToken: settings.appConfigToken ?? env.SLACK_APP_CONFIG_TOKEN ?? env.SLACK_CONFIG_TOKEN,
+        appToken: settings.appToken ?? env.SLACK_APP_TOKEN,
+    };
+}
+export function getDeployConfigError(config) {
+    if (!fs.existsSync(config.manifestPath)) {
+        return `Slack manifest not found at ${config.manifestPath}`;
+    }
+    const messages = [];
+    if (!config.appId) {
+        messages.push("Missing Slack app ID. Set slack-bridge.appId in ~/.pi/agent/settings.json or SLACK_APP_ID.");
+    }
+    if (!config.appConfigToken) {
+        const appTokenNote = config.appToken
+            ? " Note: slack-bridge.appToken / SLACK_APP_TOKEN is a Socket Mode xapp token and cannot be used with apps.manifest.update."
+            : "";
+        messages.push("Missing Slack app configuration token. Set slack-bridge.appConfigToken in ~/.pi/agent/settings.json or SLACK_APP_CONFIG_TOKEN (or SLACK_CONFIG_TOKEN)." +
+            appTokenNote);
+    }
+    return messages.length > 0 ? messages.join(" ") : null;
+}
+async function parseManifestYaml(manifestPath) {
+    try {
+        const program = [
+            "require 'yaml'",
+            "require 'json'",
+            "data = YAML.load_file(ARGV[0])",
+            "puts JSON.generate(data)",
+        ].join("; ");
+        const { stdout } = await execFile("ruby", ["-e", program, manifestPath]);
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${manifestPath} via Ruby YAML parser. Ensure Ruby is installed and the manifest is valid YAML. ${String(error)}`);
+    }
+}
+async function callSlackMethod(method, token, body) {
+    const { url, init } = buildSlackRequest(method, token, body);
+    const response = await fetch(url, init);
+    const payload = (await response.json());
+    if (!response.ok || payload.ok !== true) {
+        throw new SlackMethodError(method, payload.error ?? `http_${response.status}`, payload.errors ?? []);
+    }
+    return payload;
+}
+async function exportRemoteManifest(appId, token) {
+    const payload = await callSlackMethod("apps.manifest.export", token, { app_id: appId });
+    return payload.manifest;
+}
+async function validateManifest(manifest, token) {
+    await callSlackMethod("apps.manifest.validate", token, {
+        manifest: JSON.stringify(manifest),
+    });
+}
+async function updateManifest(appId, manifest, token) {
+    await callSlackMethod("apps.manifest.update", token, {
+        app_id: appId,
+        manifest: JSON.stringify(manifest),
+    });
+}
+export async function deploySlackManifest(config) {
+    const configError = getDeployConfigError(config);
+    if (configError) {
+        throw new Error(configError);
+    }
+    const appId = config.appId;
+    const appConfigToken = config.appConfigToken;
+    const manifest = await parseManifestYaml(config.manifestPath);
+    const previousManifest = await exportRemoteManifest(appId, appConfigToken);
+    await validateManifest(manifest, appConfigToken);
+    await updateManifest(appId, manifest, appConfigToken);
+    const updatedManifest = await exportRemoteManifest(appId, appConfigToken);
+    return {
+        appId,
+        scopeChanges: diffManifestScopes(previousManifest, updatedManifest),
+    };
+}
+export async function run() {
+    const settingsPath = process.env.PI_SETTINGS_PATH;
+    const settings = loadSettings(settingsPath);
+    const config = resolveDeployConfig(settings, process.env);
+    const result = await deploySlackManifest(config);
+    console.log(`Updated Slack app ${result.appId} from ${config.manifestPath}`);
+    for (const line of formatScopeChangeSummary(result.scopeChanges)) {
+        console.log(line);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    run().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/follower-delivery.d.ts

@@ -0,0 +1,16 @@
+export interface FollowerDeliveryState {
+    queuedButUndeliveredIds: Set<number>;
+    deliveredAwaitingAckIds: Set<number>;
+    ackInFlightIds: Set<number>;
+}
+export declare function createFollowerDeliveryState(): FollowerDeliveryState;
+export declare function resetFollowerDeliveryState(state: FollowerDeliveryState): void;
+export declare function isFollowerInboxIdTracked(state: FollowerDeliveryState, inboxId: number): boolean;
+export declare function queueFollowerInboxIds(state: FollowerDeliveryState, inboxIds: Iterable<number>): void;
+export declare function markFollowerInboxIdsDelivered(state: FollowerDeliveryState, inboxIds: Iterable<number>): void;
+export declare function hasDeliveredFollowerInboxIds(state: FollowerDeliveryState): boolean;
+export declare function takeFollowerAckBatch(state: FollowerDeliveryState): number[];
+export declare function markFollowerAckBatchSucceeded(state: FollowerDeliveryState, inboxIds: Iterable<number>): void;
+export declare function markFollowerAckBatchFailed(state: FollowerDeliveryState, inboxIds: Iterable<number>): void;
+export declare function drainFollowerAckBatches(state: FollowerDeliveryState, ackBatch: (inboxIds: number[]) => Promise<void>): Promise<void>;
+export declare function getFollowerShutdownAckIds(state: FollowerDeliveryState): number[];

package/dist/follower-delivery.js

@@ -0,0 +1,70 @@
+export function createFollowerDeliveryState() {
+    return {
+        queuedButUndeliveredIds: new Set(),
+        deliveredAwaitingAckIds: new Set(),
+        ackInFlightIds: new Set(),
+    };
+}
+export function resetFollowerDeliveryState(state) {
+    state.queuedButUndeliveredIds.clear();
+    state.deliveredAwaitingAckIds.clear();
+    state.ackInFlightIds.clear();
+}
+export function isFollowerInboxIdTracked(state, inboxId) {
+    return (state.queuedButUndeliveredIds.has(inboxId) ||
+        state.deliveredAwaitingAckIds.has(inboxId) ||
+        state.ackInFlightIds.has(inboxId));
+}
+export function queueFollowerInboxIds(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.queuedButUndeliveredIds.add(inboxId);
+    }
+}
+export function markFollowerInboxIdsDelivered(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.queuedButUndeliveredIds.delete(inboxId);
+        state.deliveredAwaitingAckIds.add(inboxId);
+    }
+}
+export function hasDeliveredFollowerInboxIds(state) {
+    return state.deliveredAwaitingAckIds.size > 0;
+}
+export function takeFollowerAckBatch(state) {
+    const batch = [...state.deliveredAwaitingAckIds];
+    for (const inboxId of batch) {
+        state.deliveredAwaitingAckIds.delete(inboxId);
+        state.ackInFlightIds.add(inboxId);
+    }
+    return batch;
+}
+export function markFollowerAckBatchSucceeded(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        state.ackInFlightIds.delete(inboxId);
+    }
+}
+export function markFollowerAckBatchFailed(state, inboxIds) {
+    for (const inboxId of inboxIds) {
+        if (state.ackInFlightIds.delete(inboxId)) {
+            state.deliveredAwaitingAckIds.add(inboxId);
+        }
+    }
+}
+export async function drainFollowerAckBatches(state, ackBatch) {
+    while (true) {
+        const batch = takeFollowerAckBatch(state);
+        if (batch.length === 0) {
+            return;
+        }
+        try {
+            await ackBatch(batch);
+            markFollowerAckBatchSucceeded(state, batch);
+        }
+        catch {
+            markFollowerAckBatchFailed(state, batch);
+            return;
+        }
+    }
+}
+export function getFollowerShutdownAckIds(state) {
+    return [...state.deliveredAwaitingAckIds];
+}