charness 0.0.0-stage → 3.0.0

package/dist/rateLimiter.js

@@ -0,0 +1,555 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKeySendRefusedError = exports.RateLimitedError = exports.formatRateSummaryLine = exports.rateLimiterConstants = exports.GlobalSendPacer = exports.shutdownDrainMaxMs = exports.globalSendIntervalMs = void 0;
+exports.__setGlobalPacerForTest = __setGlobalPacerForTest;
+exports.getActiveChatRateSummaries = getActiveChatRateSummaries;
+exports.enterShutdownDrain = enterShutdownDrain;
+exports.drainPendingSends = drainPendingSends;
+exports.checkIsRateLimited = checkIsRateLimited;
+exports.getRateLimitRemainingMs = getRateLimitRemainingMs;
+exports.checkIsRateLimitedError = checkIsRateLimitedError;
+exports.withRateLimitRetry = withRateLimitRetry;
+exports.sendUnpaced = sendUnpaced;
+exports.enqueueSend = enqueueSend;
+const utils_1 = require("./utils");
+const sessionKey_1 = require("./sessionKey");
+const sessionKeyCodec_1 = require("./connectors/telegram/sessionKeyCodec");
+const foreignKeyFallbacks_1 = require("./connectors/telegram/foreignKeyFallbacks");
+const sendRateTracker_1 = require("./utils/sendRateTracker");
+const rateLimitLog_1 = require("./utils/rateLimitLog");
+Object.defineProperty(exports, "formatRateSummaryLine", { enumerable: true, get: function () { return rateLimitLog_1.formatRateSummaryLine; } });
+const abortableFifo_1 = require("./utils/abortableFifo");
+/**
+ * @description Telegram-side rate limiting for the multi-thread bot.
+ *
+ * Three layers, with different responsibilities:
+ *
+ *   1. **Per-thread FIFO queue** (`enqueueSend`). Keyed by **SessionKey**
+ *      (`chatId+threadId`). Its only job is to preserve ordering between
+ *      *dependent* operations on the same Telegram thread — e.g. an
+ *      `editMessageText` that depends on a preceding `sendMessage`. Two
+ *      forum topics interleave freely; only within one thread is ordering
+ *      guaranteed.
+ *
+ *   2. **Global send pacer** ({@link GlobalSendPacer}). ONE process-wide
+ *      frequency gate: it releases at most one send every
+ *      {@link globalSendIntervalMs} across ALL chats (supergroup + owner DM),
+ *      FCFS among waiters. It is CLOCK-BASED and NON-BLOCKING: a permit is
+ *      granted on a timer, decoupled from whether the previous send's `fn`
+ *      finished, so a slow/stuck send never head-of-line-blocks the others.
+ *      This replaced the old per-chat priority token bucket: at ~1 send / 2 s
+ *      Telegram never 429s under normal multi-topic use, and pure temporal
+ *      FCFS (no priority classes) keeps cross-topic output in the order it
+ *      was produced.
+ *
+ *   3. **`withRateLimitRetry`.** Keyed by **chatId**. Reactive: if Telegram
+ *      still returns 429, sleep `retry_after + jitter` and retry once. A
+ *      second 429 marks the chat blocked for the cooldown and surfaces a
+ *      typed {@link RateLimitedError}. 429-state is per-chat because that's
+ *      how Telegram returns it.
+ *
+ * The layers compose: `enqueueSend(key, fn)` chains behind the previous send
+ * for the *same thread*, then waits the global pacer, then runs `fn` through
+ * `withRateLimitRetry`. `withRateLimitRetry` stays exported for callers that
+ * need the retry without the proactive pacer (e.g. boot admin / health-check
+ * operations).
+ */
+/**
+ * @description The global frequency gate: at most one send is released every
+ * {@link globalSendIntervalMs} across ALL chats. Steady state ≈ 1 send / 2 s,
+ * so Telegram's per-chat budget is never overrun under multi-topic streaming.
+ */
+exports.globalSendIntervalMs = 2000;
+/**
+ * @description Default bound (ms) for {@link drainPendingSends}: how long the
+ * graceful-shutdown flush waits for the per-thread send FIFOs to empty before
+ * giving up. Sized well under the 10s shutdown watchdog so the later steps
+ * (transient-frame sweep, update drain, `state.flush()`) keep their budgets.
+ */
+exports.shutdownDrainMaxMs = 6000;
+const realPacerClock = {
+    now: () => Date.now(),
+    setTimeout: (fn, ms) => { setTimeout(fn, ms); },
+};
+/**
+ * @description Process-wide FCFS frequency gate. `acquire()` resolves when a
+ * send permit is granted; permits are released one per {@link intervalMs},
+ * granted to waiters in strict arrival order (FCFS).
+ *
+ * CLOCK-BASED + NON-BLOCKING by design: the "next permit" time advances on a
+ * timer, never on the completion of a previous caller's send. A caller whose
+ * `fn` hangs after `acquire()` therefore cannot delay any other waiter — there
+ * is no head-of-line blocking through this gate.
+ */
+class GlobalSendPacer {
+    intervalMs;
+    clock;
+    /** Waiters parked for a permit, resolved in FIFO (arrival) order. */
+    waiters = new abortableFifo_1.AbortableFifo();
+    /** Earliest clock time the next permit may be granted. */
+    nextAllowedAt = 0;
+    /** A drain timer is already armed for the current waiter set. */
+    timerArmed = false;
+    /** Generation token that makes overdue, logically replaced timers inert. */
+    timerGeneration = 0;
+    /** Shutdown-drain mode: permits are granted immediately, no spacing. */
+    isShutdownDraining = false;
+    constructor(intervalMs, clock = realPacerClock) {
+        this.intervalMs = intervalMs;
+        this.clock = clock;
+    }
+    /** How many sends are currently parked waiting for a permit. */
+    getPendingCount() {
+        return this.waiters.size;
+    }
+    /**
+     * Flip the pacer into shutdown-drain mode: every parked waiter is released
+     * NOW (in FIFO order) and every subsequent `acquire()` resolves immediately.
+     * ONLY for the graceful-shutdown flush — during live operation the spacing is
+     * what keeps Telegram from 429ing; `withRateLimitRetry` stays on every send
+     * either way, so the small shutdown burst remains 429-safe. One-way: the
+     * process is exiting, so there is no leave-drain path.
+     */
+    enterShutdownDrain() {
+        this.isShutdownDraining = true;
+        this.invalidateDrainTimer();
+        this.waiters.resolveAll();
+    }
+    /**
+     * Resolve when a send permit is granted. Fast path: when nobody is waiting
+     * and the window is already open, grant immediately (so a send after a ≥
+     * interval-long idle never eats a needless delay). Otherwise queue FIFO and
+     * let the clock-driven drain grant it in turn.
+     */
+    acquire(signal) {
+        if (signal?.aborted)
+            return Promise.reject((0, utils_1.getAbortError)(signal));
+        if (this.isShutdownDraining)
+            return Promise.resolve();
+        const now = this.clock.now();
+        if (this.waiters.size === 0 && now >= this.nextAllowedAt) {
+            this.invalidateDrainTimer();
+            this.nextAllowedAt = now + this.intervalMs;
+            return Promise.resolve();
+        }
+        const waiter = this.waiters.wait(signal);
+        this.armDrain();
+        return waiter;
+    }
+    /** Arm a single timer to grant the head waiter when the window next opens. */
+    armDrain() {
+        if (this.timerArmed || this.waiters.size === 0)
+            return;
+        const waitMs = Math.max(this.nextAllowedAt - this.clock.now(), 0);
+        this.timerArmed = true;
+        const timerGeneration = ++this.timerGeneration;
+        this.clock.setTimeout(() => {
+            if (timerGeneration !== this.timerGeneration)
+                return;
+            this.timerArmed = false;
+            this.drainOne();
+        }, Math.max(waitMs, 1));
+    }
+    /** Logically cancel an armed timer when the pacing window is replaced. */
+    invalidateDrainTimer() {
+        if (!this.timerArmed)
+            return;
+        this.timerArmed = false;
+        this.timerGeneration += 1;
+    }
+    /** Grant exactly one permit (the head waiter), advance the clock, re-arm. */
+    drainOne() {
+        if (!this.waiters.resolveNext())
+            return;
+        // Advance from whichever is later — the scheduled slot or NOW — so a late
+        // timer never bunches two grants closer than the interval.
+        this.nextAllowedAt = Math.max(this.nextAllowedAt, this.clock.now()) + this.intervalMs;
+        if (this.waiters.size > 0)
+            this.armDrain();
+    }
+}
+exports.GlobalSendPacer = GlobalSendPacer;
+/** The process-wide pacer. Swappable in tests via {@link __setGlobalPacerForTest}. */
+let globalPacer = new GlobalSendPacer(exports.globalSendIntervalMs, realPacerClock);
+/**
+ * @description Test-only seam: replace the process pacer with one on a
+ * deterministic clock so `enqueueSend` integration tests run instantly instead
+ * of waiting real 2 s windows. Never called in production.
+ */
+function __setGlobalPacerForTest(pacer) {
+    globalPacer = pacer;
+}
+exports.rateLimiterConstants = {
+    globalSendIntervalMs: exports.globalSendIntervalMs,
+};
+/**
+ * @description Always-on per-chat outbound send-rate instrumentation
+ * (plan 2026-06-24-rate-limit-429-metrics). Records every outbound send at the
+ * single chokepoint ({@link enqueueSend}), so the rich 429 log line and the
+ * periodic rate summary can characterise how hard each chat's channel is being
+ * pushed. Bounded + best-effort — it never throws into the send hot path.
+ */
+const sendRateTracker = new sendRateTracker_1.SendRateTracker();
+/**
+ * @description Per-chat outbound-rate snapshots for every chat with activity in
+ * the rolling minute (silent chats omitted). The `bot.ts` periodic janitor logs
+ * these as `[RateLimit] rate …` lines — see {@link formatRateSummaryLine}.
+ */
+function getActiveChatRateSummaries(nowMs = Date.now()) {
+    return sendRateTracker.getActiveChats(nowMs).map((chatId) => ({
+        chatId,
+        sentPerMin: sendRateTracker.getSendsPerMin(chatId, nowMs),
+        peak10s: sendRateTracker.getPeakInSubWindow(chatId, undefined, nowMs),
+    }));
+}
+/**
+ * @description Per-thread FIFO of in-flight sends, keyed by serialised
+ * `SessionKey` (`"<chatId>:<threadId>"`).
+ *
+ * The global pacer already spaces sends across the whole process; we
+ * additionally chain sends within a single Telegram thread so
+ * `bot.telegram.sendMessage` returns to callers in the order they were queued.
+ * This preserves sequencing for operations that *do* depend on order (an
+ * `editMessageText` after the `sendMessage` whose id it edits, a
+ * `pinChatMessage` after the banner-send that produced the id) — but only
+ * within one thread, where those dependencies actually live. Different threads
+ * stay independent, so a slow send / 429 sleep in one thread never freezes the
+ * others.
+ */
+const queues = new Map();
+/**
+ * @description Flip the process pacer into shutdown-drain mode (immediate
+ * release, no 2s spacing). ONLY called from the graceful-shutdown output flush
+ * — never during live operation, where the spacing is the 429 protection.
+ * Sends drained in this mode still run through {@link withRateLimitRetry}.
+ */
+function enterShutdownDrain() {
+    globalPacer.enterShutdownDrain();
+}
+/**
+ * @description Resolve once every per-thread send FIFO is empty, or after
+ * `maxWaitMs` — whichever comes first — reporting which. Pure bookkeeping over
+ * the existing {@link queues} map: it awaits the current queue tails (which
+ * never reject — `enqueueSend` tracks them settled-only) and loops, because a
+ * send finishing may have chained a successor onto the same thread's queue.
+ * Used by the graceful-shutdown flush after {@link enterShutdownDrain} so
+ * already-enqueued output lands before the process exits.
+ */
+async function drainPendingSends(maxWaitMs = exports.shutdownDrainMaxMs) {
+    const deadline = Date.now() + maxWaitMs;
+    while (queues.size > 0) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            return 'timeout';
+        const tails = [...queues.values()];
+        const isTimedOut = await Promise.race([
+            Promise.all(tails).then(() => false),
+            new Promise((resolve) => {
+                const timer = setTimeout(() => resolve(true), remainingMs);
+                timer.unref?.();
+            }),
+        ]);
+        if (isTimedOut)
+            return 'timeout';
+        // The settled tails delete their map entries in `enqueueSend`'s `finally`,
+        // which runs a microtask after the tracked promise resolves — yield one
+        // macrotask so those deletes land before the emptiness re-check.
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return 'drained';
+}
+const rateLimitStates = new Map();
+function getRateLimitState(chatId) {
+    let state = rateLimitStates.get(chatId);
+    if (!state) {
+        state = { blockedUntil: 0 };
+        rateLimitStates.set(chatId, state);
+    }
+    return state;
+}
+/**
+ * @description Check if a chat is currently rate-limited by Telegram.
+ * Used by the output debounce to lengthen delays during cooldown.
+ */
+function checkIsRateLimited(chatId) {
+    const state = getRateLimitState(chatId);
+    return Date.now() < state.blockedUntil;
+}
+/** Get remaining cooldown time in ms, 0 if not limited. */
+function getRateLimitRemainingMs(chatId) {
+    const state = getRateLimitState(chatId);
+    return Math.max(0, state.blockedUntil - Date.now());
+}
+/**
+ * @name RateLimitedError
+ * @description Thrown by {@link withRateLimitRetry} when a send still gets a
+ * 429 *after* the single retry. Carries the chat id and the remaining cooldown
+ * as a typed signal. The global pacer makes a sustained 429 essentially
+ * impossible, so this no longer drives any redelivery re-arm — it stays a typed
+ * error so a caller can recognise the 429 class if it ever surfaces.
+ *
+ * The original Telegram error payload is preserved on `response` so the
+ * existing classifier helpers (`checkIsApiError`, `getErrorCode`,
+ * `getErrorDescription`) keep working unchanged on this error.
+ */
+class RateLimitedError extends Error {
+    chatId;
+    retryAfterMs;
+    response;
+    constructor(chatId, retryAfterMs, original) {
+        super(`Telegram rate limit on chat ${chatId}, cooldown ${Math.ceil(retryAfterMs / 1000)}s`);
+        this.chatId = chatId;
+        this.retryAfterMs = retryAfterMs;
+        this.name = 'RateLimitedError';
+        this.response = original?.response;
+    }
+}
+exports.RateLimitedError = RateLimitedError;
+function checkIsRateLimitedError(err) {
+    return err instanceof RateLimitedError;
+}
+function checkIsTelegramRateLimitError(err) {
+    if (typeof err !== 'object' || err === null)
+        return false;
+    const e = err;
+    return e.response?.error_code === 429;
+}
+/** Default cooldown when Telegram omits `retry_after` (mirrors {@link getRetryAfterMs}). */
+const defaultRetryAfterSec = 30;
+function getRetryAfterMs(err) {
+    const retryAfterSec = err.response?.parameters?.retry_after ?? defaultRetryAfterSec;
+    // Add jitter: multiply by random factor 1.0–1.3 to avoid thundering herd
+    const jitter = 1 + Math.random() * 0.3;
+    return Math.ceil(retryAfterSec * 1000 * jitter);
+}
+/** The raw `retry_after` Telegram returned (seconds) — the value we log. */
+function getRawRetryAfterSec(err) {
+    return err.response?.parameters?.retry_after ?? defaultRetryAfterSec;
+}
+/**
+ * @description Emit the rich, greppable `[RateLimit] 429` instrumentation line
+ * for one 429, gathering the measured send-rate (from the tracker) and the
+ * global pacer's current queue depth. Best-effort: a failure to build the line
+ * must never mask the 429 handling itself.
+ */
+function logRateLimit429(chatId, err, isAfterRetry) {
+    try {
+        const line = (0, rateLimitLog_1.formatRateLimit429Line)({
+            chatId,
+            retryAfterSec: getRawRetryAfterSec(err),
+            sentPerMin: sendRateTracker.getSendsPerMin(chatId),
+            peak10s: sendRateTracker.getPeakInSubWindow(chatId),
+            queuedSends: globalPacer.getPendingCount(),
+            isAfterRetry,
+        });
+        if (isAfterRetry)
+            console.error(line);
+        else
+            console.log(line);
+    }
+    catch { /* instrumentation must never break 429 handling */ }
+}
+/**
+ * @description Wraps a Telegram API call with 429 retry-after handling.
+ * On 429: waits the specified retry_after + jitter, retries once.
+ * If second attempt also fails with 429: marks chat as rate-limited, throws.
+ *
+ * Most call sites should prefer {@link enqueueSend}, which runs `fn` through
+ * the global pacer *and* `withRateLimitRetry`. Use this function directly only
+ * when you must bypass the proactive pacer (e.g. admin / health-check
+ * operations during boot).
+ */
+async function withRateLimitRetry(chatId, operation, signal) {
+    if (signal?.aborted)
+        throw (0, utils_1.getAbortError)(signal);
+    const state = getRateLimitState(chatId);
+    // If currently rate-limited, wait for cooldown
+    const remainingMs = state.blockedUntil - Date.now();
+    if (remainingMs > 0) {
+        console.log(`[RateLimit] chat ${chatId} blocked for ${Math.ceil(remainingMs / 1000)}s, waiting...`);
+        await (0, utils_1.sleep)(remainingMs, signal);
+    }
+    try {
+        if (signal?.aborted)
+            throw (0, utils_1.getAbortError)(signal);
+        return await operation();
+    }
+    catch (err) {
+        if (!checkIsTelegramRateLimitError(err))
+            throw err;
+        const waitMs = getRetryAfterMs(err);
+        state.blockedUntil = Date.now() + waitMs;
+        logRateLimit429(chatId, err, /* isAfterRetry */ false);
+        await (0, utils_1.sleep)(waitMs, signal);
+        // Single retry
+        try {
+            if (signal?.aborted)
+                throw (0, utils_1.getAbortError)(signal);
+            const result = await operation();
+            state.blockedUntil = 0;
+            return result;
+        }
+        catch (retryErr) {
+            if (checkIsTelegramRateLimitError(retryErr)) {
+                const secondWaitMs = getRetryAfterMs(retryErr);
+                state.blockedUntil = Date.now() + secondWaitMs;
+                logRateLimit429(chatId, retryErr, /* isAfterRetry */ true);
+                // Surface a typed error so a caller can recognise the 429 class. The
+                // global pacer makes a sustained double-429 essentially impossible, so
+                // this no longer re-arms any redelivery.
+                throw new RateLimitedError(chatId, secondWaitMs, retryErr);
+            }
+            throw retryErr;
+        }
+    }
+}
+/**
+ * @description A send for a conversation of another platform (Jira connector
+ * plan J2b, R2): its operation never runs. Like a failed Telegram call it
+ * rejects, so an awaiting caller takes its error path.
+ */
+class ForeignKeySendRefusedError extends Error {
+    constructor(key) {
+        super(`Telegram send refused: ${key.platform} conversation ${key.space}/${key.thread} ${foreignKeyFallbacks_1.notTelegramChatPhrase}`);
+        this.name = 'ForeignKeySendRefusedError';
+    }
+}
+exports.ForeignKeySendRefusedError = ForeignKeySendRefusedError;
+/** The second line behind the bot's per-primitive guards; logs once per entry point and conversation. */
+const checkIsTelegramSendKey = (0, foreignKeyFallbacks_1.createTelegramPrimitiveGuard)();
+/**
+ * The refusal of a foreign key's send. A handler is attached before it is
+ * returned, so a caller that fires and forgets it never raises an unhandled
+ * rejection — which would end the whole process.
+ */
+function getForeignKeySendRefusal(key) {
+    const refusal = Promise.reject(new ForeignKeySendRefusedError(key));
+    refusal.catch(() => { });
+    return refusal;
+}
+/**
+ * @description The shared send tail both the paced and unpaced paths end in:
+ * record the outbound send for the per-chat rate summary (best-effort — never
+ * throws into the send path), then run `fn` through the reactive 429 retry.
+ * Keeping it in one place stops {@link enqueueSend} and {@link sendUnpaced} from
+ * drifting on 429-safety or instrumentation.
+ */
+function recordAndRetry(key, fn, signal) {
+    // Record exactly one outbound send per logical send (best-effort
+    // instrumentation — never let it break a send).
+    const chatId = (0, sessionKeyCodec_1.getTelegramChatId)(key);
+    try {
+        sendRateTracker.recordSend(chatId);
+    }
+    catch { /* never throw into the send path */ }
+    return withRateLimitRetry(chatId, fn, signal);
+}
+/**
+ * @description Send a Telegram operation OUTSIDE the global message pacer and
+ * the per-thread FIFO — still 429-safe ({@link withRateLimitRetry}) and still
+ * counted by {@link sendRateTracker}, but WITHOUT taking a
+ * {@link globalSendIntervalMs} permit and WITHOUT chaining behind the thread's
+ * other sends. Runs immediately.
+ *
+ * Reserved for the rare, non-output sends that must not consume the paced
+ * message budget nor queue behind streaming agent output:
+ *  - the typing indicator (`sendChatAction` — not a Telegram message, not
+ *    subject to the flood limit, so pacing it just wastes ~60% of the budget);
+ *  - the voice-transcript echo (the user's own input being acknowledged, which
+ *    should surface ahead of queued agent output).
+ *
+ * Do NOT route ordinary agent-output `sendMessage`s through this — that would
+ * break the FCFS ordering the pacer guarantees.
+ */
+function sendUnpaced(key, fn, signal) {
+    // Not `async`, for the same reason as {@link enqueueSend}.
+    if (!checkIsTelegramSendKey(key, 'sendUnpaced'))
+        return getForeignKeySendRefusal(key);
+    return sendTelegramUnpaced(key, fn, signal);
+}
+/** Async, so a synchronous throw on the way to the send still arrives as a rejection. */
+async function sendTelegramUnpaced(key, fn, signal) {
+    return recordAndRetry(key, fn, signal);
+}
+/** Reject while queued, but never race a started operation's cleanup/result. */
+function waitForQueuedExecution(execution, checkOperationStarted, signal) {
+    if (!signal)
+        return execution;
+    if (signal.aborted)
+        return Promise.reject((0, utils_1.getAbortError)(signal));
+    return new Promise((resolve, reject) => {
+        const handleAbort = () => {
+            if (!checkOperationStarted())
+                reject((0, utils_1.getAbortError)(signal));
+        };
+        signal.addEventListener('abort', handleAbort, { once: true });
+        execution.then((result) => {
+            signal.removeEventListener('abort', handleAbort);
+            resolve(result);
+        }, (error) => {
+            signal.removeEventListener('abort', handleAbort);
+            reject(error);
+        });
+    });
+}
+/**
+ * @description Send a Telegram operation through the per-thread FIFO queue, the
+ * global send pacer, and per-chat 429 retry.
+ *
+ * - **Serialised per thread**: the next send for the same `SessionKey` only runs
+ *   after this one settles (success or failure). Sends for *different* threads
+ *   run concurrently, gated only by the global pacer.
+ * - **Paced globally**: {@link GlobalSendPacer} releases ≤1 send /
+ *   {@link globalSendIntervalMs} across all chats, FCFS. Permits are granted on
+ *   a clock, so a slow send never blocks another thread's permit.
+ * - **Retry on 429**: reactive backoff via {@link withRateLimitRetry}.
+ *
+ * Errors from the operation are returned to the caller (we don't swallow
+ * them — only the queue tail is swallowed so a single failure doesn't poison
+ * every subsequent send on that thread).
+ *
+ * @example
+ *   await enqueueSend(key, () =>
+ *     bot.telegram.sendMessage(key.chatId, text, { message_thread_id: key.threadId }));
+ */
+function enqueueSend(key, fn, signal) {
+    // Not `async`: an async function would wrap the handled refusal in a NEW, unhandled promise.
+    if (!checkIsTelegramSendKey(key, 'enqueueSend'))
+        return getForeignKeySendRefusal(key);
+    return enqueueTelegramSend(key, fn, signal);
+}
+async function enqueueTelegramSend(key, fn, signal) {
+    if (signal?.aborted)
+        throw (0, utils_1.getAbortError)(signal);
+    const queueKey = (0, sessionKey_1.keyToString)(key);
+    const prev = queues.get(queueKey);
+    let isOperationStarted = false;
+    const exec = async () => {
+        await globalPacer.acquire(signal);
+        return recordAndRetry(key, () => {
+            isOperationStarted = true;
+            return fn();
+        }, signal);
+    };
+    // Chain: wait for prev (ignore its errors), then run our exec.
+    const execution = (async () => {
+        if (prev) {
+            try {
+                await prev;
+            }
+            catch { /* swallow predecessor errors */ }
+        }
+        if (signal?.aborted)
+            throw (0, utils_1.getAbortError)(signal);
+        return exec();
+    })();
+    const tracked = execution.then(() => undefined, () => undefined);
+    queues.set(queueKey, tracked);
+    void tracked.then(() => {
+        if (queues.get(queueKey) === tracked) {
+            queues.delete(queueKey);
+        }
+    });
+    return waitForQueuedExecution(execution, () => isOperationStarted, signal);
+}
+//# sourceMappingURL=rateLimiter.js.map

package/dist/rateLimiter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateLimiter.js","sourceRoot":"","sources":["../src/rateLimiter.ts"],"names":[],"mappings":"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"}

package/dist/requests/answerRequest.d.ts

@@ -0,0 +1,57 @@
+import { type SessionKey } from '../sessionKey';
+import { type AnswerSinks } from '../platform/answerSink';
+import type { RequestLedger } from './requestLedger';
+import type { RequestAnswerKind } from './types';
+/**
+ * @description The `answer_request` contract (request/answer core S3), kept out
+ * of the MCP surface so the rules are testable without HTTP:
+ *
+ *   unknown id, or an id outside the caller's scope → refused, nothing sent
+ *     (the two read the same, so a session cannot probe other topics' ids)
+ *   delivery through the request platform's answer sink fails → refused, the
+ *     request is unchanged and the agent may retry
+ *   delivered, request open:   progress → counted, stays open
+ *                              question / final → closes the request
+ *   delivered, request closed: nothing changes (a late answer from a turn that
+ *     outlived its request is still delivered — content is never dropped); a
+ *     superseded request's result names the request that replaced it and says
+ *     its prompt follows — the agent answers only what that one adds, never the
+ *     same work twice (Claude Code delivers a message written mid-turn only
+ *     after the turn ends, so this is the normal order there)
+ */
+/** The longest answer body accepted; the sinks split it to their surface's limits. */
+export declare const answerBodyMaxLength = 100000;
+/**
+ * @name AnswerRequestDeps
+ * @description The ledger (awaited until loaded — the bot MCP server serves
+ * before the boot finished) and the answer sinks by platform.
+ * `onAnswerDelivered` hears every answer that reached the requester, to an open
+ * request or a closed one (the wake-up engine follows what comes after a final).
+ */
+export interface AnswerRequestDeps {
+    ledger: Pick<RequestLedger, 'whenLoaded' | 'getRequest' | 'updateOpenRequest' | 'closeRequest'>;
+    answerSinks: AnswerSinks;
+    onAnswerDelivered?: (key: SessionKey, requestId: string, kind: RequestAnswerKind) => void;
+}
+/**
+ * @name AnswerRequestArgs
+ * @description One `answer_request` call. `checkIsConversationInScope` answers
+ * whether the calling session's token covers a conversation (serialized key).
+ */
+export interface AnswerRequestArgs {
+    requestId: string;
+    kind: RequestAnswerKind;
+    body: string;
+    checkIsConversationInScope: (conversationKey: string) => boolean;
+}
+/** @description What the tool reports back to the agent. */
+export type AnswerRequestOutcome = {
+    ok: true;
+    message: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** @description Deliver one answer and apply the close rules. */
+export declare function answerRequest(deps: AnswerRequestDeps, args: AnswerRequestArgs): Promise<AnswerRequestOutcome>;
+//# sourceMappingURL=answerRequest.d.ts.map

package/dist/requests/answerRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answerRequest.d.ts","sourceRoot":"","sources":["../../src/requests/answerRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAuB,iBAAiB,EAAsB,MAAM,SAAS,CAAC;AAE1F;;;;;;;;;;;;;;;;GAgBG;AAEH,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,SAAU,CAAC;AAS3C;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,YAAY,GAAG,mBAAmB,GAAG,cAAc,CAAC,CAAC;IAChG,WAAW,EAAE,WAAW,CAAC;IACzB,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC3F;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B,EAAE,CAAC,eAAe,EAAE,MAAM,KAAK,OAAO,CAAC;CAClE;AAED,4DAA4D;AAC5D,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAyBhG,iEAAiE;AACjE,wBAAsB,aAAa,CAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA4CnH"}