discoclaw 0.1.0

package/dist/discord/durable-memory.test.js

@@ -0,0 +1,281 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { loadDurableMemory, saveDurableMemory, deriveItemId, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, CURRENT_VERSION, } from './durable-memory.js';
+async function makeTmpDir() {
+    return fs.mkdtemp(path.join(os.tmpdir(), 'durable-memory-test-'));
+}
+function emptyStore() {
+    return { version: 1, updatedAt: 0, items: [] };
+}
+function makeItem(overrides = {}) {
+    return {
+        id: 'durable-test1234',
+        kind: 'fact',
+        text: 'test item',
+        tags: [],
+        status: 'active',
+        source: { type: 'manual' },
+        createdAt: 1000,
+        updatedAt: 1000,
+        ...overrides,
+    };
+}
+describe('loadDurableMemory', () => {
+    it('returns null for missing file', async () => {
+        const dir = await makeTmpDir();
+        const result = await loadDurableMemory(dir, 'nonexistent');
+        expect(result).toBeNull();
+    });
+    it('parses valid store', async () => {
+        const dir = await makeTmpDir();
+        const store = { version: 1, updatedAt: 1000, items: [] };
+        await fs.writeFile(path.join(dir, '12345.json'), JSON.stringify(store), 'utf8');
+        const result = await loadDurableMemory(dir, '12345');
+        expect(result).toEqual(store);
+    });
+    it('returns null on malformed JSON', async () => {
+        const dir = await makeTmpDir();
+        await fs.writeFile(path.join(dir, 'bad.json'), '{not json!!!', 'utf8');
+        const result = await loadDurableMemory(dir, 'bad');
+        expect(result).toBeNull();
+    });
+    it('rejects path traversal in userId', async () => {
+        const dir = await makeTmpDir();
+        await expect(loadDurableMemory(dir, '../evil')).rejects.toThrow(/Invalid userId/);
+    });
+    it('returns store unchanged for version-1 store (migration no-op)', async () => {
+        const dir = await makeTmpDir();
+        const store = { version: 1, updatedAt: 1000, items: [] };
+        await fs.writeFile(path.join(dir, 'user1.json'), JSON.stringify(store), 'utf8');
+        const result = await loadDurableMemory(dir, 'user1');
+        expect(result).toEqual(store);
+    });
+    it('returns empty store for unsupported version', async () => {
+        const dir = await makeTmpDir();
+        const store = { version: 99, updatedAt: 1000, items: [] };
+        await fs.writeFile(path.join(dir, 'user2.json'), JSON.stringify(store), 'utf8');
+        const result = await loadDurableMemory(dir, 'user2');
+        expect(result).toMatchObject({ version: CURRENT_VERSION, items: [] });
+    });
+    it('returns null for store missing version field', async () => {
+        const dir = await makeTmpDir();
+        const store = { updatedAt: 1000, items: [] };
+        await fs.writeFile(path.join(dir, 'user3.json'), JSON.stringify(store), 'utf8');
+        const result = await loadDurableMemory(dir, 'user3');
+        expect(result).toBeNull();
+    });
+});
+describe('saveDurableMemory — path traversal', () => {
+    it('rejects path traversal in userId', async () => {
+        const dir = await makeTmpDir();
+        const store = { version: 1, updatedAt: 0, items: [] };
+        await expect(saveDurableMemory(dir, '../evil', store)).rejects.toThrow(/Invalid userId/);
+    });
+});
+describe('saveDurableMemory', () => {
+    it('creates file, overwrites existing', async () => {
+        const dir = await makeTmpDir();
+        const store1 = { version: 1, updatedAt: 1000, items: [] };
+        await saveDurableMemory(dir, '12345', store1);
+        const raw1 = await fs.readFile(path.join(dir, '12345.json'), 'utf8');
+        expect(JSON.parse(raw1)).toEqual(store1);
+        const store2 = { version: 1, updatedAt: 2000, items: [] };
+        await saveDurableMemory(dir, '12345', store2);
+        const raw2 = await fs.readFile(path.join(dir, '12345.json'), 'utf8');
+        expect(JSON.parse(raw2)).toEqual(store2);
+    });
+    it('creates parent directory', async () => {
+        const dir = await makeTmpDir();
+        const nested = path.join(dir, 'a', 'b', 'c');
+        const store = { version: 1, updatedAt: 1, items: [] };
+        await saveDurableMemory(nested, 'user', store);
+        const raw = await fs.readFile(path.join(nested, 'user.json'), 'utf8');
+        expect(JSON.parse(raw)).toEqual(store);
+    });
+});
+describe('deriveItemId', () => {
+    it('produces consistent IDs for same input', () => {
+        const id1 = deriveItemId('fact', 'I prefer TypeScript');
+        const id2 = deriveItemId('fact', 'I prefer TypeScript');
+        expect(id1).toBe(id2);
+        expect(id1).toMatch(/^durable-[0-9a-f]{8}$/);
+    });
+    it('produces different IDs for different input', () => {
+        const id1 = deriveItemId('fact', 'I prefer TypeScript');
+        const id2 = deriveItemId('fact', 'I prefer JavaScript');
+        expect(id1).not.toBe(id2);
+    });
+    it('normalizes whitespace', () => {
+        const id1 = deriveItemId('fact', '  I   prefer   TypeScript  ');
+        const id2 = deriveItemId('fact', 'I prefer TypeScript');
+        expect(id1).toBe(id2);
+    });
+    it('produces different IDs for different kinds with same text', () => {
+        const factId = deriveItemId('fact', 'uses TypeScript');
+        const toolId = deriveItemId('tool', 'uses TypeScript');
+        const prefId = deriveItemId('preference', 'uses TypeScript');
+        expect(factId).not.toBe(toolId);
+        expect(factId).not.toBe(prefId);
+        expect(toolId).not.toBe(prefId);
+    });
+});
+describe('addItem', () => {
+    it('creates new item with kind=fact', () => {
+        const store = emptyStore();
+        const result = addItem(store, 'User prefers TypeScript', { type: 'manual' }, 200);
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].kind).toBe('fact');
+        expect(result.items[0].text).toBe('User prefers TypeScript');
+        expect(result.items[0].status).toBe('active');
+        expect(result.items[0].id).toMatch(/^durable-/);
+    });
+    it('preserves explicit kind parameter', () => {
+        const store = emptyStore();
+        addItem(store, 'Uses VS Code', { type: 'summary' }, 200, 'tool');
+        expect(store.items).toHaveLength(1);
+        expect(store.items[0].kind).toBe('tool');
+        expect(store.items[0].source.type).toBe('summary');
+    });
+    it('updates existing item with same derived ID (dedup)', () => {
+        const store = emptyStore();
+        addItem(store, 'User prefers TypeScript', { type: 'manual' }, 200);
+        expect(store.items).toHaveLength(1);
+        const originalCreatedAt = store.items[0].createdAt;
+        addItem(store, 'User prefers TypeScript', { type: 'discord', channelId: 'ch1' }, 200);
+        expect(store.items).toHaveLength(1);
+        expect(store.items[0].source.type).toBe('discord');
+        expect(store.items[0].createdAt).toBe(originalCreatedAt);
+    });
+    it('enforces maxItems cap (drops oldest deprecated first)', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'old-dep', status: 'deprecated', updatedAt: 100 }), makeItem({ id: 'old-active', status: 'active', text: 'old active', updatedAt: 200 }));
+        // maxItems=2, adding a third should drop the deprecated item
+        addItem(store, 'new item', { type: 'manual' }, 2);
+        expect(store.items).toHaveLength(2);
+        expect(store.items.find((it) => it.id === 'old-dep')).toBeUndefined();
+        expect(store.items.find((it) => it.id === 'old-active')).toBeDefined();
+    });
+    it('drops oldest active when no deprecated items remain', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'active1', status: 'active', text: 'first', updatedAt: 100 }), makeItem({ id: 'active2', status: 'active', text: 'second', updatedAt: 200 }));
+        addItem(store, 'third item', { type: 'manual' }, 2);
+        expect(store.items).toHaveLength(2);
+        expect(store.items.find((it) => it.id === 'active1')).toBeUndefined();
+    });
+});
+describe('deprecateItems', () => {
+    it('matches by 60% text-length threshold', () => {
+        const store = emptyStore();
+        // text = "TypeScript" (10 chars), substring = "TypeScrip" (9 chars) -> 90% >= 60%
+        store.items.push(makeItem({ text: 'TypeScript', status: 'active' }));
+        const { deprecatedCount } = deprecateItems(store, 'TypeScrip');
+        expect(deprecatedCount).toBe(1);
+        expect(store.items[0].status).toBe('deprecated');
+    });
+    it('does not match when substring is too short', () => {
+        const store = emptyStore();
+        // text = "TypeScript" (10 chars), substring = "Type" (4 chars) -> 40% < 60%
+        store.items.push(makeItem({ text: 'TypeScript', status: 'active' }));
+        const { deprecatedCount } = deprecateItems(store, 'Type');
+        expect(deprecatedCount).toBe(0);
+        expect(store.items[0].status).toBe('active');
+    });
+    it('ignores already-deprecated items', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ text: 'TypeScript', status: 'deprecated' }));
+        const { deprecatedCount } = deprecateItems(store, 'TypeScript');
+        expect(deprecatedCount).toBe(0);
+    });
+    it('is case-insensitive', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ text: 'TypeScript', status: 'active' }));
+        const { deprecatedCount } = deprecateItems(store, 'typescript');
+        expect(deprecatedCount).toBe(1);
+    });
+    it('returns 0 when no match', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ text: 'TypeScript', status: 'active' }));
+        const { deprecatedCount } = deprecateItems(store, 'completely unrelated');
+        expect(deprecatedCount).toBe(0);
+    });
+});
+describe('selectItemsForInjection', () => {
+    it('returns active items only, sorted by recency', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'a', text: 'old', status: 'active', updatedAt: 100 }), makeItem({ id: 'b', text: 'deprecated', status: 'deprecated', updatedAt: 300 }), makeItem({ id: 'c', text: 'new', status: 'active', updatedAt: 200 }));
+        const items = selectItemsForInjection(store, 10000);
+        expect(items).toHaveLength(2);
+        expect(items[0].id).toBe('c'); // newer first
+        expect(items[1].id).toBe('a');
+    });
+    it('respects char budget', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'a', text: 'first item text', status: 'active', updatedAt: 200 }), makeItem({ id: 'b', text: 'second item text', status: 'active', updatedAt: 100 }));
+        // Budget just enough for one item line
+        const items = selectItemsForInjection(store, 80);
+        expect(items).toHaveLength(1);
+        expect(items[0].id).toBe('a');
+    });
+    it('returns empty with maxChars = 0', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'a', text: 'some item', status: 'active', updatedAt: 200 }));
+        const items = selectItemsForInjection(store, 0);
+        expect(items).toHaveLength(0);
+    });
+    it('skips oversized newest item and still includes smaller older items that fit', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'new-big', text: 'x'.repeat(600), status: 'active', updatedAt: 300 }), makeItem({ id: 'older-small', text: 'small item', status: 'active', updatedAt: 200 }));
+        const items = selectItemsForInjection(store, 120);
+        expect(items).toHaveLength(1);
+        expect(items[0].id).toBe('older-small');
+    });
+});
+describe('formatDurableSection', () => {
+    it('formats items correctly', () => {
+        const items = [
+            makeItem({
+                kind: 'fact',
+                text: 'User prefers TypeScript over JavaScript.',
+                source: { type: 'manual' },
+                updatedAt: new Date('2026-02-09').getTime(),
+            }),
+            makeItem({
+                kind: 'project',
+                text: 'Current project: discoclaw memory system.',
+                source: { type: 'discord' },
+                updatedAt: new Date('2026-02-09').getTime(),
+            }),
+        ];
+        const result = formatDurableSection(items);
+        expect(result).toContain('- [fact] User prefers TypeScript over JavaScript. (src: manual, updated 2026-02-09)');
+        expect(result).toContain('- [project] Current project: discoclaw memory system. (src: discord, updated 2026-02-09)');
+    });
+    it('includes channel name when present in source', () => {
+        const items = [
+            makeItem({
+                kind: 'fact',
+                text: 'Prefers Rust',
+                source: { type: 'manual', channelName: 'dev' },
+                updatedAt: new Date('2026-01-15').getTime(),
+            }),
+        ];
+        const result = formatDurableSection(items);
+        expect(result).toContain('#dev');
+        expect(result).toMatch(/src: manual, #dev, updated/);
+    });
+    it('omits channel name when absent from source', () => {
+        const items = [
+            makeItem({
+                kind: 'fact',
+                text: 'Prefers Rust',
+                source: { type: 'manual' },
+                updatedAt: new Date('2026-01-15').getTime(),
+            }),
+        ];
+        const result = formatDurableSection(items);
+        expect(result).not.toContain('#');
+        expect(result).toMatch(/src: manual, updated/);
+    });
+});

package/dist/discord/durable-write-queue.js

@@ -0,0 +1,4 @@
+import { KeyedQueue } from '../group-queue.js';
+// Shared write queue for durable memory. Serializes writes per userId so
+// concurrent callers (memory-commands, user-turn-to-durable, etc.) don't race.
+export const durableWriteQueue = new KeyedQueue();

package/dist/discord/file-download.js

@@ -0,0 +1,308 @@
+// Keep in sync with image-download.ts
+const ALLOWED_HOSTS = new Set(['cdn.discordapp.com', 'media.discordapp.net']);
+/** Max bytes per individual text file (100 KB). Files exceeding this are truncated. */
+const MAX_FILE_BYTES = 100 * 1024;
+/** Max total bytes across all text files in one message (200 KB). */
+const MAX_TOTAL_BYTES = 200 * 1024;
+/** Per-file download timeout (10 seconds). */
+const DOWNLOAD_TIMEOUT_MS = 10_000;
+/** MIME types that are treated as text (checked via startsWith for text/*). */
+const TEXT_APPLICATION_TYPES = new Set([
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/typescript',
+    'application/toml',
+    'application/sql',
+    'application/graphql',
+    'application/x-httpd-php',
+    'application/x-sh',
+    'application/x-yaml',
+]);
+/** Extension-to-MIME fallback map for text types. */
+const EXT_TO_TEXT_MIME = {
+    // --- Existing ---
+    txt: 'text/plain',
+    json: 'application/json',
+    csv: 'text/csv',
+    md: 'text/markdown',
+    js: 'application/javascript',
+    ts: 'application/typescript',
+    xml: 'application/xml',
+    html: 'text/html',
+    yml: 'text/yaml',
+    yaml: 'text/yaml',
+    py: 'text/x-script',
+    rb: 'text/x-script',
+    sh: 'text/x-script',
+    bash: 'text/x-script',
+    zsh: 'text/x-script',
+    // --- Web / frontend ---
+    jsx: 'application/javascript',
+    tsx: 'application/typescript',
+    mjs: 'application/javascript',
+    cjs: 'application/javascript',
+    mts: 'application/typescript',
+    cts: 'application/typescript',
+    css: 'text/css',
+    scss: 'text/css',
+    sass: 'text/css',
+    less: 'text/css',
+    vue: 'text/html',
+    svelte: 'text/html',
+    astro: 'text/html',
+    htm: 'text/html',
+    // --- Template engines ---
+    njk: 'text/html',
+    ejs: 'text/html',
+    hbs: 'text/html',
+    pug: 'text/html',
+    // --- Systems / compiled (source is text) ---
+    c: 'text/x-script',
+    h: 'text/x-script',
+    cpp: 'text/x-script',
+    cxx: 'text/x-script',
+    cc: 'text/x-script',
+    hpp: 'text/x-script',
+    hxx: 'text/x-script',
+    cs: 'text/x-script',
+    java: 'text/x-script',
+    kt: 'text/x-script',
+    kts: 'text/x-script',
+    scala: 'text/x-script',
+    go: 'text/x-script',
+    rs: 'text/x-script',
+    swift: 'text/x-script',
+    m: 'text/x-script',
+    mm: 'text/x-script',
+    zig: 'text/x-script',
+    nim: 'text/x-script',
+    v: 'text/x-script',
+    d: 'text/x-script',
+    // --- Scripting / dynamic ---
+    php: 'text/x-script',
+    pl: 'text/x-script',
+    pm: 'text/x-script',
+    r: 'text/x-script',
+    lua: 'text/x-script',
+    tcl: 'text/x-script',
+    ex: 'text/x-script',
+    exs: 'text/x-script',
+    erl: 'text/x-script',
+    hrl: 'text/x-script',
+    clj: 'text/x-script',
+    cljs: 'text/x-script',
+    cljc: 'text/x-script',
+    hs: 'text/x-script',
+    ml: 'text/x-script',
+    mli: 'text/x-script',
+    fs: 'text/x-script',
+    fsx: 'text/x-script',
+    jl: 'text/x-script',
+    dart: 'text/x-script',
+    groovy: 'text/x-script',
+    gradle: 'text/x-script',
+    ps1: 'text/x-script',
+    psm1: 'text/x-script',
+    fish: 'text/x-script',
+    nix: 'text/x-script',
+    gd: 'text/x-script',
+    // --- Config / data ---
+    toml: 'application/toml',
+    ini: 'text/plain',
+    cfg: 'text/plain',
+    conf: 'text/plain',
+    env: 'text/plain',
+    properties: 'text/plain',
+    json5: 'application/json',
+    jsonc: 'application/json',
+    editorconfig: 'text/plain',
+    gitignore: 'text/plain',
+    gitattributes: 'text/plain',
+    dockerignore: 'text/plain',
+    npmrc: 'text/plain',
+    nvmrc: 'text/plain',
+    prettierrc: 'text/plain',
+    eslintrc: 'text/plain',
+    babelrc: 'text/plain',
+    // --- Infrastructure / IaC ---
+    tf: 'text/plain',
+    tfvars: 'text/plain',
+    hcl: 'text/plain',
+    // --- Data / query / IDL ---
+    sql: 'application/sql',
+    graphql: 'application/graphql',
+    gql: 'application/graphql',
+    proto: 'text/plain',
+    prisma: 'text/plain',
+    // --- Markup / docs ---
+    rst: 'text/plain',
+    tex: 'text/plain',
+    latex: 'text/plain',
+    adoc: 'text/plain',
+    org: 'text/plain',
+    wiki: 'text/plain',
+    rdoc: 'text/plain',
+    // --- Build / CI ---
+    // Note: bare Dockerfile/Makefile/Gemfile (no extension) won't match via
+    // extension extraction — lastIndexOf('.') returns -1 for extensionless filenames.
+    // These entries only cover the foo.dockerfile / foo.makefile variant.
+    dockerfile: 'text/plain',
+    makefile: 'text/plain',
+    cmake: 'text/plain',
+    rake: 'text/x-script',
+    gemfile: 'text/x-script',
+    // --- Shell / terminal ---
+    ksh: 'text/x-script',
+    csh: 'text/x-script',
+    tcsh: 'text/x-script',
+    bat: 'text/x-script',
+    cmd: 'text/x-script',
+    awk: 'text/x-script',
+    // --- Misc text ---
+    log: 'text/plain',
+    diff: 'text/plain',
+    patch: 'text/plain',
+    svg: 'text/xml',
+};
+/**
+ * Resolve a text MIME type from contentType or file extension.
+ * Returns the MIME string if it's a supported text type, null otherwise.
+ */
+export function resolveTextType(attachment) {
+    if (attachment.contentType) {
+        const mime = attachment.contentType.split(';')[0].trim().toLowerCase();
+        if (mime.startsWith('text/'))
+            return mime;
+        if (TEXT_APPLICATION_TYPES.has(mime))
+            return mime;
+    }
+    const name = attachment.name ?? '';
+    const dotIdx = name.lastIndexOf('.');
+    if (dotIdx >= 0) {
+        const ext = name.slice(dotIdx + 1).toLowerCase();
+        const mime = EXT_TO_TEXT_MIME[ext];
+        if (mime)
+            return mime;
+    }
+    return null;
+}
+/** Check if a MIME type is a supported text type. */
+export function isTextType(mime) {
+    return mime.startsWith('text/') || TEXT_APPLICATION_TYPES.has(mime);
+}
+/** Sanitize an attachment filename for display. */
+function safeName(attachment) {
+    const raw = attachment.name ?? 'unknown';
+    return raw.replace(/[\x00-\x1f]/g, '').slice(0, 100).trim() || 'unknown';
+}
+/**
+ * Classify attachments into text, unsupported, and image (skipped) buckets.
+ * Image attachments are excluded — they're handled by image-download.ts.
+ */
+export function classifyAttachments(attachments) {
+    const text = [];
+    const unsupported = [];
+    for (const att of attachments) {
+        const textMime = resolveTextType(att);
+        if (textMime) {
+            text.push({ attachment: att, mime: textMime });
+        }
+        else {
+            unsupported.push(att);
+        }
+    }
+    return { text, unsupported };
+}
+/**
+ * Download non-image text attachments from a Discord message.
+ *
+ * - Filters for text-like MIME types
+ * - Truncates files exceeding MAX_FILE_BYTES with a marker
+ * - Skips files once MAX_TOTAL_BYTES is reached
+ * - Notes unsupported attachment types in errors
+ */
+export async function downloadTextAttachments(attachments) {
+    const { text: candidates, unsupported } = classifyAttachments(attachments);
+    const errors = [];
+    // Note unsupported types
+    for (const att of unsupported) {
+        const name = safeName(att);
+        const mime = att.contentType?.split(';')[0].trim() ?? 'unknown';
+        errors.push(`[Unsupported attachment: ${name} (${mime})]`);
+    }
+    if (candidates.length === 0)
+        return { texts: [], errors };
+    const texts = [];
+    let totalBytes = 0;
+    for (const { attachment, mime } of candidates) {
+        const name = safeName(attachment);
+        // Total budget check
+        if (totalBytes >= MAX_TOTAL_BYTES) {
+            errors.push(`${name}: skipped (total size limit exceeded)`);
+            continue;
+        }
+        // SSRF protection
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(attachment.url);
+        }
+        catch {
+            errors.push(`${name}: invalid URL`);
+            continue;
+        }
+        if (parsedUrl.protocol !== 'https:' || !ALLOWED_HOSTS.has(parsedUrl.hostname)) {
+            errors.push(`${name}: blocked (non-Discord CDN host)`);
+            continue;
+        }
+        // Pre-check size from Discord metadata for total budget
+        const metaSize = attachment.size ?? 0;
+        if (metaSize > 0 && totalBytes + metaSize > MAX_TOTAL_BYTES) {
+            errors.push(`${name}: skipped (total size limit exceeded)`);
+            continue;
+        }
+        try {
+            const response = await fetch(attachment.url, {
+                signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
+                redirect: 'error',
+            });
+            if (!response.ok) {
+                errors.push(`${name}: HTTP ${response.status}`);
+                continue;
+            }
+            const buffer = Buffer.from(await response.arrayBuffer());
+            totalBytes += buffer.length;
+            // Decode as UTF-8
+            let content;
+            try {
+                const decoder = new TextDecoder('utf-8', { fatal: true });
+                content = decoder.decode(buffer);
+            }
+            catch {
+                errors.push(`${name}: not valid UTF-8 text`);
+                continue;
+            }
+            // Truncate if exceeding per-file limit
+            if (buffer.length > MAX_FILE_BYTES) {
+                const truncated = content.slice(0, MAX_FILE_BYTES);
+                texts.push({ name, content: truncated + '\n[truncated at 100KB]' });
+            }
+            else {
+                texts.push({ name, content });
+            }
+        }
+        catch (err) {
+            const errObj = err instanceof Error ? err : null;
+            if (errObj?.name === 'TimeoutError' || errObj?.name === 'AbortError') {
+                errors.push(`${name}: download timed out`);
+            }
+            else if (errObj?.name === 'TypeError' && String(errObj.message).includes('redirect')) {
+                errors.push(`${name}: blocked (unexpected redirect)`);
+            }
+            else {
+                errors.push(`${name}: download failed`);
+            }
+        }
+    }
+    return { texts, errors };
+}