discoclaw 0.1.0

package/dist/discord/inflight-replies.js

@@ -0,0 +1,228 @@
+import fs from 'node:fs/promises';
+import { NO_MENTIONS } from './allowed-mentions.js';
+const INTERRUPTED_GRACEFUL = '*(Interrupted \u2014 bot is restarting.)*';
+const INTERRUPTED_COLD = '*(Interrupted \u2014 bot was restarted.)*';
+// --- Module state ---
+const registry = new Map();
+let shuttingDown = false;
+let dataFilePath = null;
+// --- Public API ---
+/**
+ * Configure the path for the persistent inflight.json file.
+ * Call once at startup after dataDir is resolved.
+ */
+export function setDataFilePath(filePath) {
+    dataFilePath = filePath;
+}
+/**
+ * Register an in-progress Discord reply. Returns a disposer function
+ * that unregisters the entry. Use in try/finally to guarantee cleanup.
+ */
+export function registerInFlightReply(reply, channelId, messageId, label) {
+    if (shuttingDown) {
+        // Drain already happened — immediately edit and discard.
+        reply.edit({ content: INTERRUPTED_GRACEFUL, allowedMentions: NO_MENTIONS }).catch(() => { });
+        return () => { };
+    }
+    const key = `${channelId}:${messageId}`;
+    registry.set(key, { reply, channelId, messageId, label });
+    // Best-effort persist for cold-start recovery.
+    persistAdd({ channelId, messageId }).catch(() => { });
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        registry.delete(key);
+        persistRemove({ channelId, messageId }).catch(() => { });
+    };
+}
+/**
+ * Number of currently tracked in-flight replies.
+ */
+export function inFlightReplyCount() {
+    return registry.size;
+}
+/**
+ * Returns true if there is at least one in-flight reply for the given channelId.
+ */
+export function hasInFlightForChannel(channelId) {
+    for (const entry of registry.values()) {
+        if (entry.channelId === channelId)
+            return true;
+    }
+    return false;
+}
+/**
+ * Returns true once drainInFlightReplies has been called.
+ * Streaming loops should check this and no-op if true,
+ * preventing the "Interrupted" text from being overwritten.
+ */
+export function isShuttingDown() {
+    return shuttingDown;
+}
+/**
+ * Atomically snapshot and clear the registry, set the shutdown flag,
+ * then edit all tracked replies in parallel with a timeout.
+ */
+export async function drainInFlightReplies(opts) {
+    const timeoutMs = opts?.timeoutMs ?? 3000;
+    const log = opts?.log;
+    // Atomic snapshot + clear + flag.
+    const entries = Array.from(registry.values());
+    registry.clear();
+    shuttingDown = true;
+    if (entries.length === 0) {
+        // Clear persistent file even if registry was empty (belt-and-suspenders).
+        await persistClear().catch(() => { });
+        return;
+    }
+    log?.info({ count: entries.length }, 'inflight:drain editing in-flight replies');
+    const editPromises = entries.map((entry) => entry.reply
+        .edit({ content: INTERRUPTED_GRACEFUL, allowedMentions: NO_MENTIONS })
+        .then(() => {
+        log?.info({ channelId: entry.channelId, messageId: entry.messageId, label: entry.label }, 'inflight:drain edited');
+    })
+        .catch((err) => {
+        log?.warn({ err, channelId: entry.channelId, messageId: entry.messageId }, 'inflight:drain edit failed');
+    }));
+    await Promise.race([
+        Promise.allSettled(editPromises),
+        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+    await persistClear().catch(() => { });
+}
+// --- Cold-start recovery ---
+/**
+ * Load orphaned reply entries from the persistent file (for cold-start recovery).
+ */
+export function loadOrphanedReplies(filePath) {
+    return fs.readFile(filePath, 'utf-8')
+        .then((raw) => {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((e) => typeof e === 'object' && e !== null &&
+            typeof e.channelId === 'string' &&
+            typeof e.messageId === 'string');
+    })
+        .catch(() => []);
+}
+/**
+ * On startup, detect and clean up any orphaned messages left by a previous unclean exit.
+ */
+export async function cleanupOrphanedReplies(opts) {
+    const { client, dataFilePath: filePath, log, timeoutMs = 5000 } = opts;
+    const orphans = await loadOrphanedReplies(filePath);
+    if (orphans.length === 0)
+        return;
+    log?.info({ count: orphans.length }, 'inflight:cold-start cleaning up orphaned replies');
+    const editPromises = orphans.map(async (orphan) => {
+        try {
+            const channel = await client.channels.fetch(orphan.channelId);
+            if (!channel || typeof channel.messages?.fetch !== 'function') {
+                log?.warn({ channelId: orphan.channelId }, 'inflight:cold-start channel not fetchable');
+                return;
+            }
+            const message = await channel.messages.fetch(orphan.messageId);
+            await message.edit({ content: INTERRUPTED_COLD, allowedMentions: NO_MENTIONS });
+            log?.info({ channelId: orphan.channelId, messageId: orphan.messageId }, 'inflight:cold-start edited orphan');
+        }
+        catch (err) {
+            log?.warn({ err, channelId: orphan.channelId, messageId: orphan.messageId }, 'inflight:cold-start orphan cleanup failed');
+        }
+    });
+    await Promise.race([
+        Promise.allSettled(editPromises),
+        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+    // Clear the file after processing.
+    try {
+        await fs.unlink(filePath);
+    }
+    catch {
+        // Already gone or inaccessible.
+    }
+}
+// --- Persistence helpers (serial queue + atomic write-tmp-rename) ---
+// Serial promise queue prevents read-modify-write races when multiple
+// handlers register/dispose concurrently (maxConcurrentInvocations > 1).
+let persistQueue = Promise.resolve();
+function enqueuePersist(fn) {
+    const next = persistQueue.then(fn, fn);
+    persistQueue = next.then(() => { }, () => { });
+    return next;
+}
+async function readPersistedEntries() {
+    if (!dataFilePath)
+        return [];
+    try {
+        const raw = await fs.readFile(dataFilePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+async function writePersistedEntries(entries) {
+    if (!dataFilePath)
+        return;
+    const tmpPath = `${dataFilePath}.tmp.${process.pid}`;
+    await fs.writeFile(tmpPath, JSON.stringify(entries) + '\n', 'utf-8');
+    await fs.rename(tmpPath, dataFilePath);
+}
+function persistAdd(entry) {
+    return enqueuePersist(async () => {
+        if (!dataFilePath)
+            return;
+        const entries = await readPersistedEntries();
+        const key = `${entry.channelId}:${entry.messageId}`;
+        // Avoid duplicates.
+        if (!entries.some((e) => `${e.channelId}:${e.messageId}` === key)) {
+            entries.push(entry);
+        }
+        await writePersistedEntries(entries);
+    });
+}
+function persistRemove(entry) {
+    return enqueuePersist(async () => {
+        if (!dataFilePath)
+            return;
+        const entries = await readPersistedEntries();
+        const key = `${entry.channelId}:${entry.messageId}`;
+        const filtered = entries.filter((e) => `${e.channelId}:${e.messageId}` !== key);
+        await writePersistedEntries(filtered);
+    });
+}
+function persistClear() {
+    return enqueuePersist(async () => {
+        if (!dataFilePath)
+            return;
+        try {
+            await fs.unlink(dataFilePath);
+        }
+        catch {
+            // File doesn't exist or inaccessible — fine.
+        }
+    });
+}
+// --- Test helpers ---
+/**
+ * Wait for all queued persistence operations to complete.
+ * Only for use in tests — avoids flaky setTimeout-based waits.
+ */
+export function _waitForPendingPersists() {
+    return persistQueue;
+}
+/**
+ * Reset module state. Only for use in tests.
+ */
+export function _resetForTest() {
+    registry.clear();
+    shuttingDown = false;
+    dataFilePath = null;
+    persistQueue = Promise.resolve();
+}

package/dist/discord/inflight-replies.test.js

@@ -0,0 +1,295 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { registerInFlightReply, inFlightReplyCount, hasInFlightForChannel, isShuttingDown, drainInFlightReplies, loadOrphanedReplies, cleanupOrphanedReplies, setDataFilePath, _waitForPendingPersists, _resetForTest, } from './inflight-replies.js';
+function mockReply() {
+    return { edit: vi.fn().mockResolvedValue(undefined) };
+}
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+let tmpDir;
+beforeEach(async () => {
+    _resetForTest();
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'inflight-test-'));
+});
+afterEach(async () => {
+    _resetForTest();
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+});
+// ---------------------------------------------------------------------------
+// Disposer pattern
+// ---------------------------------------------------------------------------
+describe('registerInFlightReply', () => {
+    it('returns a disposer function that unregisters the entry', () => {
+        const reply = mockReply();
+        const dispose = registerInFlightReply(reply, 'ch1', 'msg1', 'test');
+        expect(inFlightReplyCount()).toBe(1);
+        dispose();
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('double-dispose is a no-op', () => {
+        const reply = mockReply();
+        const dispose = registerInFlightReply(reply, 'ch1', 'msg1', 'test');
+        expect(inFlightReplyCount()).toBe(1);
+        dispose();
+        dispose(); // second call should not throw or change count
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('tracks multiple entries independently', () => {
+        const dispose1 = registerInFlightReply(mockReply(), 'ch1', 'msg1', 'a');
+        const dispose2 = registerInFlightReply(mockReply(), 'ch2', 'msg2', 'b');
+        expect(inFlightReplyCount()).toBe(2);
+        dispose1();
+        expect(inFlightReplyCount()).toBe(1);
+        dispose2();
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('registration after drain immediately edits and returns no-op disposer', async () => {
+        await drainInFlightReplies();
+        expect(isShuttingDown()).toBe(true);
+        const reply = mockReply();
+        const dispose = registerInFlightReply(reply, 'ch1', 'msg1', 'late');
+        // Should have been immediately edited.
+        expect(reply.edit).toHaveBeenCalledOnce();
+        expect(reply.edit.mock.calls[0][0].content).toContain('Interrupted');
+        // Disposer is a no-op; count stays 0.
+        expect(inFlightReplyCount()).toBe(0);
+        dispose();
+        expect(inFlightReplyCount()).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// hasInFlightForChannel
+// ---------------------------------------------------------------------------
+describe('hasInFlightForChannel', () => {
+    it('returns false with no registrations', () => {
+        expect(hasInFlightForChannel('ch1')).toBe(false);
+    });
+    it('returns true when a reply is registered for that channelId', () => {
+        registerInFlightReply(mockReply(), 'ch1', 'msg1', 'test');
+        expect(hasInFlightForChannel('ch1')).toBe(true);
+    });
+    it('returns false for a different channelId', () => {
+        registerInFlightReply(mockReply(), 'ch1', 'msg1', 'test');
+        expect(hasInFlightForChannel('ch2')).toBe(false);
+    });
+    it('returns false after the disposer is called', () => {
+        const dispose = registerInFlightReply(mockReply(), 'ch1', 'msg1', 'test');
+        expect(hasInFlightForChannel('ch1')).toBe(true);
+        dispose();
+        expect(hasInFlightForChannel('ch1')).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// drainInFlightReplies
+// ---------------------------------------------------------------------------
+describe('drainInFlightReplies', () => {
+    it('edits all registered replies with interrupted message', async () => {
+        const reply1 = mockReply();
+        const reply2 = mockReply();
+        registerInFlightReply(reply1, 'ch1', 'msg1', 'a');
+        registerInFlightReply(reply2, 'ch2', 'msg2', 'b');
+        expect(inFlightReplyCount()).toBe(2);
+        await drainInFlightReplies();
+        expect(reply1.edit).toHaveBeenCalledOnce();
+        expect(reply1.edit.mock.calls[0][0].content).toContain('Interrupted');
+        expect(reply1.edit.mock.calls[0][0].content).toContain('restarting');
+        expect(reply2.edit).toHaveBeenCalledOnce();
+        expect(reply2.edit.mock.calls[0][0].content).toContain('Interrupted');
+    });
+    it('sets isShuttingDown flag to true', async () => {
+        expect(isShuttingDown()).toBe(false);
+        await drainInFlightReplies();
+        expect(isShuttingDown()).toBe(true);
+    });
+    it('clears registry (second drain is a no-op)', async () => {
+        const reply = mockReply();
+        registerInFlightReply(reply, 'ch1', 'msg1', 'a');
+        await drainInFlightReplies();
+        expect(inFlightReplyCount()).toBe(0);
+        expect(reply.edit).toHaveBeenCalledOnce();
+        // Second drain should not edit again.
+        await drainInFlightReplies();
+        expect(reply.edit).toHaveBeenCalledOnce();
+    });
+    it('edit failures do not block other edits or throw', async () => {
+        const reply1 = { edit: vi.fn().mockRejectedValue(new Error('Discord error')) };
+        const reply2 = mockReply();
+        registerInFlightReply(reply1, 'ch1', 'msg1', 'a');
+        registerInFlightReply(reply2, 'ch2', 'msg2', 'b');
+        // Should not throw.
+        const log = mockLog();
+        await drainInFlightReplies({ log });
+        // reply2 should still have been edited.
+        expect(reply2.edit).toHaveBeenCalledOnce();
+        // The warning should have been logged.
+        expect(log.warn).toHaveBeenCalled();
+    });
+    it('respects timeout (does not hang on slow edits)', async () => {
+        const slowReply = {
+            edit: vi.fn().mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 10_000))),
+        };
+        registerInFlightReply(slowReply, 'ch1', 'msg1', 'slow');
+        const start = Date.now();
+        await drainInFlightReplies({ timeoutMs: 100 });
+        const elapsed = Date.now() - start;
+        // Should complete in roughly the timeout, not 10s.
+        expect(elapsed).toBeLessThan(2000);
+        expect(isShuttingDown()).toBe(true);
+    });
+    it('drain with empty registry is a no-op', async () => {
+        expect(inFlightReplyCount()).toBe(0);
+        await drainInFlightReplies();
+        expect(isShuttingDown()).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Persistent file
+// ---------------------------------------------------------------------------
+describe('persistent file', () => {
+    it('register writes entry, dispose removes it', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        setDataFilePath(filePath);
+        const dispose = registerInFlightReply(mockReply(), 'ch1', 'msg1', 'test');
+        await _waitForPendingPersists();
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const entries = JSON.parse(raw);
+        expect(entries).toHaveLength(1);
+        expect(entries[0]).toEqual({ channelId: 'ch1', messageId: 'msg1' });
+        dispose();
+        await _waitForPendingPersists();
+        const raw2 = await fs.readFile(filePath, 'utf-8');
+        const entries2 = JSON.parse(raw2);
+        expect(entries2).toHaveLength(0);
+    });
+    it('drain clears the persistent file', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        setDataFilePath(filePath);
+        registerInFlightReply(mockReply(), 'ch1', 'msg1', 'test');
+        await _waitForPendingPersists();
+        // File should exist.
+        const stat = await fs.stat(filePath).catch(() => null);
+        expect(stat).not.toBeNull();
+        await drainInFlightReplies();
+        // File should be removed.
+        const stat2 = await fs.stat(filePath).catch(() => null);
+        expect(stat2).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// loadOrphanedReplies
+// ---------------------------------------------------------------------------
+describe('loadOrphanedReplies', () => {
+    it('returns entries from a valid file', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        await fs.writeFile(filePath, JSON.stringify([
+            { channelId: 'ch1', messageId: 'msg1' },
+            { channelId: 'ch2', messageId: 'msg2' },
+        ]));
+        const result = await loadOrphanedReplies(filePath);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ channelId: 'ch1', messageId: 'msg1' });
+    });
+    it('returns empty array for missing file', async () => {
+        const result = await loadOrphanedReplies(path.join(tmpDir, 'nonexistent.json'));
+        expect(result).toEqual([]);
+    });
+    it('returns empty array for corrupt file', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        await fs.writeFile(filePath, 'not json');
+        const result = await loadOrphanedReplies(filePath);
+        expect(result).toEqual([]);
+    });
+    it('filters out malformed entries', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        await fs.writeFile(filePath, JSON.stringify([
+            { channelId: 'ch1', messageId: 'msg1' },
+            { bad: true },
+            null,
+            { channelId: 'ch2' }, // missing messageId
+        ]));
+        const result = await loadOrphanedReplies(filePath);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ channelId: 'ch1', messageId: 'msg1' });
+    });
+});
+// ---------------------------------------------------------------------------
+// cleanupOrphanedReplies (cold-start recovery)
+// ---------------------------------------------------------------------------
+describe('cleanupOrphanedReplies', () => {
+    it('fetches and edits orphaned messages, then clears file', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        await fs.writeFile(filePath, JSON.stringify([
+            { channelId: 'ch1', messageId: 'msg1' },
+        ]));
+        const editFn = vi.fn().mockResolvedValue(undefined);
+        const mockMessage = { edit: editFn };
+        const mockChannel = {
+            messages: { fetch: vi.fn().mockResolvedValue(mockMessage) },
+        };
+        const client = {
+            channels: { fetch: vi.fn().mockResolvedValue(mockChannel) },
+        };
+        const log = mockLog();
+        await cleanupOrphanedReplies({ client, dataFilePath: filePath, log });
+        expect(client.channels.fetch).toHaveBeenCalledWith('ch1');
+        expect(mockChannel.messages.fetch).toHaveBeenCalledWith('msg1');
+        expect(editFn).toHaveBeenCalledOnce();
+        expect(editFn.mock.calls[0][0].content).toContain('Interrupted');
+        expect(editFn.mock.calls[0][0].content).toContain('was restarted');
+        expect(log.info).toHaveBeenCalled();
+        // File should be deleted.
+        const stat = await fs.stat(filePath).catch(() => null);
+        expect(stat).toBeNull();
+    });
+    it('is a no-op when file is missing', async () => {
+        const filePath = path.join(tmpDir, 'nonexistent.json');
+        const client = {
+            channels: { fetch: vi.fn() },
+        };
+        const log = mockLog();
+        await cleanupOrphanedReplies({ client, dataFilePath: filePath, log });
+        expect(client.channels.fetch).not.toHaveBeenCalled();
+    });
+    it('handles stale/unfetchable entries gracefully', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        await fs.writeFile(filePath, JSON.stringify([
+            { channelId: 'ch1', messageId: 'msg1' },
+            { channelId: 'ch2', messageId: 'msg2' },
+        ]));
+        const editFn = vi.fn().mockResolvedValue(undefined);
+        const mockMessage = { edit: editFn };
+        const mockChannel = {
+            messages: { fetch: vi.fn().mockResolvedValue(mockMessage) },
+        };
+        const client = {
+            channels: {
+                fetch: vi.fn()
+                    .mockResolvedValueOnce(mockChannel)
+                    .mockRejectedValueOnce(new Error('Unknown Channel')),
+            },
+        };
+        const log = mockLog();
+        await cleanupOrphanedReplies({ client, dataFilePath: filePath, log });
+        // First entry edited, second failed gracefully.
+        expect(editFn).toHaveBeenCalledOnce();
+        expect(log.warn).toHaveBeenCalled();
+    });
+    it('respects timeout', async () => {
+        const filePath = path.join(tmpDir, 'inflight.json');
+        await fs.writeFile(filePath, JSON.stringify([
+            { channelId: 'ch1', messageId: 'msg1' },
+        ]));
+        const client = {
+            channels: {
+                fetch: vi.fn().mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 10_000))),
+            },
+        };
+        const start = Date.now();
+        await cleanupOrphanedReplies({ client, dataFilePath: filePath, timeoutMs: 100 });
+        const elapsed = Date.now() - start;
+        expect(elapsed).toBeLessThan(2000);
+    });
+});

package/dist/discord/json-extract.js

@@ -0,0 +1,110 @@
+function isAllowedStart(ch, opts) {
+    if (opts.arrayOnly)
+        return ch === '[';
+    if (opts.objectOnly)
+        return ch === '{';
+    return ch === '[' || ch === '{';
+}
+function parseBalancedJsonCandidate(raw, start) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < raw.length; i++) {
+        const ch = raw[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{' || ch === '[') {
+            depth++;
+            continue;
+        }
+        if (ch === '}' || ch === ']') {
+            depth--;
+            if (depth === 0) {
+                return raw.slice(start, i + 1);
+            }
+            if (depth < 0)
+                return null;
+        }
+    }
+    return null;
+}
+function extractFromText(raw, opts) {
+    for (let i = 0; i < raw.length; i++) {
+        const ch = raw[i];
+        if (!isAllowedStart(ch, opts))
+            continue;
+        const candidate = parseBalancedJsonCandidate(raw, i);
+        if (!candidate)
+            continue;
+        try {
+            const parsed = JSON.parse(candidate);
+            if (opts.arrayOnly && !Array.isArray(parsed))
+                continue;
+            if (opts.objectOnly && (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object')) {
+                continue;
+            }
+            return candidate;
+        }
+        catch {
+            // Keep scanning for the next candidate.
+        }
+    }
+    return null;
+}
+function extractFencedBlocks(raw) {
+    const blocks = [];
+    let cursor = 0;
+    while (cursor < raw.length) {
+        const open = raw.indexOf('```', cursor);
+        if (open === -1)
+            break;
+        const langLineEnd = raw.indexOf('\n', open + 3);
+        if (langLineEnd === -1)
+            break;
+        const lang = raw.slice(open + 3, langLineEnd).trim().toLowerCase();
+        const close = raw.indexOf('```', langLineEnd + 1);
+        if (close === -1)
+            break;
+        blocks.push({
+            lang,
+            body: raw.slice(langLineEnd + 1, close),
+        });
+        cursor = close + 3;
+    }
+    return blocks;
+}
+function isJsonFenceLanguage(lang) {
+    if (!lang)
+        return true;
+    return lang === 'json' || lang === 'jsonc' || lang === 'javascript' || lang === 'js';
+}
+export function extractFirstJsonValue(raw, opts = {}) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const fencedBlocks = extractFencedBlocks(trimmed);
+    for (const block of fencedBlocks) {
+        if (!isJsonFenceLanguage(block.lang))
+            continue;
+        const fromFence = extractFromText(block.body, opts);
+        if (fromFence)
+            return fromFence;
+    }
+    return extractFromText(trimmed, opts);
+}

package/dist/discord/keyed-queue.js

@@ -0,0 +1,22 @@
+export class KeyedQueue {
+    tails = new Map();
+    async run(key, fn) {
+        const prev = this.tails.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise((r) => {
+            release = r;
+        });
+        const tail = prev.then(() => current, () => current);
+        this.tails.set(key, tail);
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.tails.get(key) === tail) {
+                this.tails.delete(key);
+            }
+        }
+    }
+}