@otto-assistant/bridge 0.4.92

package/dist/hrana-server.test.js

@@ -0,0 +1,370 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { describe, test, expect, afterAll } from 'vitest';
+import Database from 'libsql';
+import { PrismaLibSql } from '@prisma/adapter-libsql';
+import { PrismaClient } from './generated/client.js';
+import { createLibsqlHandler, createLibsqlNodeHandler, libsqlExecutor, } from 'libsqlproxy';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function migrateSchema(prisma) {
+    const schemaPath = path.join(__dirname, '../src/schema.sql');
+    const sql = fs.readFileSync(schemaPath, 'utf-8');
+    const statements = sql
+        .split(';')
+        .map((s) => s
+        .split('\n')
+        .filter((line) => !line.trimStart().startsWith('--'))
+        .join('\n')
+        .trim())
+        .filter((s) => s.length > 0 &&
+        !/^CREATE\s+TABLE\s+["']?sqlite_sequence["']?\s*\(/i.test(s))
+        .map((s) => s
+        .replace(/^CREATE\s+UNIQUE\s+INDEX\b(?!\s+IF)/i, 'CREATE UNIQUE INDEX IF NOT EXISTS')
+        .replace(/^CREATE\s+INDEX\b(?!\s+IF)/i, 'CREATE INDEX IF NOT EXISTS'));
+    for (const statement of statements) {
+        await prisma.$executeRawUnsafe(statement);
+    }
+}
+describe('hrana-server', () => {
+    let testServer = null;
+    let testDb = null;
+    let prisma = null;
+    const dbPath = path.join(process.cwd(), `tmp/test-hrana-${crypto.randomUUID().slice(0, 8)}.db`);
+    afterAll(async () => {
+        if (prisma)
+            await prisma.$disconnect();
+        if (testServer)
+            await new Promise((resolve) => {
+                testServer.close(() => {
+                    resolve();
+                });
+            });
+        if (testDb)
+            testDb.close();
+        try {
+            fs.unlinkSync(dbPath);
+        }
+        catch (e) {
+            console.warn('cleanup:', dbPath, e.message);
+        }
+        try {
+            fs.unlinkSync(dbPath + '-wal');
+        }
+        catch (e) {
+            console.warn('cleanup:', dbPath + '-wal', e.message);
+        }
+        try {
+            fs.unlinkSync(dbPath + '-shm');
+        }
+        catch (e) {
+            console.warn('cleanup:', dbPath + '-shm', e.message);
+        }
+    });
+    test('prisma CRUD through hrana server', async () => {
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        const database = new Database(dbPath);
+        database.exec('PRAGMA journal_mode = WAL');
+        database.exec('PRAGMA busy_timeout = 5000');
+        testDb = database;
+        const port = 10000 + Math.floor(Math.random() * 50000);
+        await new Promise((resolve, reject) => {
+            const hranaFetchHandler = createLibsqlHandler(libsqlExecutor(database));
+            const hranaNodeHandler = createLibsqlNodeHandler(hranaFetchHandler);
+            const srv = http.createServer(hranaNodeHandler);
+            srv.on('error', reject);
+            srv.listen(port, '127.0.0.1', () => {
+                testServer = srv;
+                resolve();
+            });
+        });
+        const adapter = new PrismaLibSql({ url: `http://127.0.0.1:${port}` });
+        prisma = new PrismaClient({ adapter });
+        await migrateSchema(prisma);
+        // Create
+        const created = await prisma.thread_sessions.create({
+            data: {
+                thread_id: 'hrana-test-thread',
+                session_id: 'hrana-test-session',
+            },
+        });
+        expect(created.thread_id).toMatchInlineSnapshot(`"hrana-test-thread"`);
+        expect(created.session_id).toMatchInlineSnapshot(`"hrana-test-session"`);
+        // Read
+        const found = await prisma.thread_sessions.findUnique({
+            where: { thread_id: 'hrana-test-thread' },
+        });
+        expect(found?.session_id).toMatchInlineSnapshot(`"hrana-test-session"`);
+        // Update
+        await prisma.thread_sessions.update({
+            where: { thread_id: 'hrana-test-thread' },
+            data: { session_id: 'updated-session' },
+        });
+        const updated = await prisma.thread_sessions.findUnique({
+            where: { thread_id: 'hrana-test-thread' },
+        });
+        expect(updated?.session_id).toMatchInlineSnapshot(`"updated-session"`);
+        // Delete
+        await prisma.thread_sessions.delete({
+            where: { thread_id: 'hrana-test-thread' },
+        });
+        const deleted = await prisma.thread_sessions.findUnique({
+            where: { thread_id: 'hrana-test-thread' },
+        });
+        expect(deleted).toBeNull();
+    }, 30_000);
+    test('$executeRawUnsafe works for PRAGMAs', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        const result = await prisma.$executeRawUnsafe('PRAGMA journal_mode');
+        expect(typeof result).toBe('number');
+    });
+    test('batch transaction via Prisma $transaction', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        const [s1, s2] = await prisma.$transaction([
+            prisma.thread_sessions.create({
+                data: { thread_id: 'batch-1', session_id: 'sess-1' },
+            }),
+            prisma.thread_sessions.create({
+                data: { thread_id: 'batch-2', session_id: 'sess-2' },
+            }),
+        ]);
+        expect(s1.thread_id).toMatchInlineSnapshot(`"batch-1"`);
+        expect(s2.thread_id).toMatchInlineSnapshot(`"batch-2"`);
+        const count = await prisma.thread_sessions.count({
+            where: { thread_id: { in: ['batch-1', 'batch-2'] } },
+        });
+        expect(count).toBe(2);
+        await prisma.thread_sessions.deleteMany({
+            where: { thread_id: { in: ['batch-1', 'batch-2'] } },
+        });
+    }, 30_000);
+    test('schema migration DDL via $executeRawUnsafe', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        // CREATE TABLE IF NOT EXISTS is idempotent — running migrateSchema again
+        // should not throw even though tables already exist.
+        await migrateSchema(prisma);
+        // Verify DDL actually created the tables by querying sqlite_master
+        const tables = await prisma.$queryRawUnsafe(`SELECT name FROM sqlite_master WHERE type='table' ORDER BY name`);
+        const tableNames = tables.map((t) => t.name);
+        expect(tableNames).toContain('thread_sessions');
+        expect(tableNames).toContain('ipc_requests');
+        expect(tableNames).toContain('scheduled_tasks');
+        // Also verify indexes were created
+        const indexes = await prisma.$queryRawUnsafe(`SELECT name FROM sqlite_master WHERE type='index' AND name LIKE '%idx%' ORDER BY name`);
+        const indexNames = indexes.map((i) => i.name);
+        expect(indexNames).toContain('ipc_requests_status_created_at_idx');
+        expect(indexNames).toContain('scheduled_tasks_status_next_run_at_idx');
+        // Test CREATE INDEX IF NOT EXISTS is also idempotent
+        await prisma.$executeRawUnsafe(`CREATE INDEX IF NOT EXISTS "ipc_requests_status_created_at_idx" ON "ipc_requests"("status", "created_at")`);
+    });
+    test('concurrent queries via Promise.all', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        // Seed some data for concurrent reads
+        const threads = Array.from({ length: 5 }, (_, i) => ({
+            thread_id: `concurrent-${i}`,
+            session_id: `sess-concurrent-${i}`,
+        }));
+        for (const t of threads) {
+            await prisma.thread_sessions.create({ data: t });
+        }
+        // Simulate kimaki's pattern of parallel Prisma queries
+        const [allThreads, count, single, filtered] = await Promise.all([
+            prisma.thread_sessions.findMany({
+                where: { thread_id: { startsWith: 'concurrent-' } },
+                orderBy: { thread_id: 'asc' },
+            }),
+            prisma.thread_sessions.count({
+                where: { thread_id: { startsWith: 'concurrent-' } },
+            }),
+            prisma.thread_sessions.findUnique({
+                where: { thread_id: 'concurrent-2' },
+            }),
+            prisma.thread_sessions.findMany({
+                where: { thread_id: { in: ['concurrent-0', 'concurrent-4'] } },
+                orderBy: { thread_id: 'asc' },
+            }),
+        ]);
+        expect(allThreads.length).toBe(5);
+        expect(count).toBe(5);
+        expect(single?.session_id).toMatchInlineSnapshot(`"sess-concurrent-2"`);
+        expect(filtered.map((f) => f.thread_id)).toMatchInlineSnapshot(`
+      [
+        "concurrent-0",
+        "concurrent-4",
+      ]
+    `);
+        // Cleanup
+        await prisma.thread_sessions.deleteMany({
+            where: { thread_id: { startsWith: 'concurrent-' } },
+        });
+    }, 30_000);
+    test('$queryRawUnsafe for PRAGMAs that return values', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        // PRAGMA that returns a value — journal_mode should be WAL
+        const journalMode = await prisma.$queryRawUnsafe('PRAGMA journal_mode');
+        expect(journalMode[0]?.journal_mode).toMatchInlineSnapshot(`"wal"`);
+        // PRAGMA busy_timeout returns the current timeout value
+        const busyTimeout = await prisma.$queryRawUnsafe('PRAGMA busy_timeout');
+        expect(busyTimeout[0]?.busy_timeout).toMatchInlineSnapshot(`undefined`);
+        // PRAGMA table_info returns column metadata
+        const tableInfo = await prisma.$queryRawUnsafe(`PRAGMA table_info('ipc_requests')`);
+        const colNames = tableInfo.map((c) => c.name);
+        expect(colNames).toMatchInlineSnapshot(`
+      [
+        "id",
+        "type",
+        "session_id",
+        "thread_id",
+        "payload",
+        "response",
+        "status",
+        "created_at",
+        "updated_at",
+      ]
+    `);
+    });
+    test('updateMany with complex WHERE using in operator', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        // Seed: create a thread + multiple IPC requests in different statuses
+        // (mirrors kimaki's cancelAllPendingIpcRequests pattern)
+        await prisma.thread_sessions.create({
+            data: { thread_id: 'ipc-test-thread', session_id: 'ipc-test-session' },
+        });
+        const statuses = ['pending', 'pending', 'processing', 'completed'];
+        for (let i = 0; i < statuses.length; i++) {
+            await prisma.ipc_requests.create({
+                data: {
+                    id: `ipc-req-${i}`,
+                    type: 'file_upload',
+                    session_id: 'ipc-test-session',
+                    thread_id: 'ipc-test-thread',
+                    payload: JSON.stringify({ prompt: `test-${i}` }),
+                    status: statuses[i],
+                },
+            });
+        }
+        // updateMany with WHERE status IN ['pending', 'processing']
+        const result = await prisma.ipc_requests.updateMany({
+            where: { status: { in: ['pending', 'processing'] } },
+            data: {
+                status: 'cancelled',
+                response: JSON.stringify({ error: 'Bot shutting down' }),
+            },
+        });
+        expect(result.count).toBe(3);
+        // Verify: only 'completed' row is untouched
+        const remaining = await prisma.ipc_requests.findMany({
+            where: { thread_id: 'ipc-test-thread' },
+            orderBy: { id: 'asc' },
+            select: { id: true, status: true },
+        });
+        expect(remaining).toMatchInlineSnapshot(`
+      [
+        {
+          "id": "ipc-req-0",
+          "status": "cancelled",
+        },
+        {
+          "id": "ipc-req-1",
+          "status": "cancelled",
+        },
+        {
+          "id": "ipc-req-2",
+          "status": "cancelled",
+        },
+        {
+          "id": "ipc-req-3",
+          "status": "completed",
+        },
+      ]
+    `);
+        // Cleanup
+        await prisma.ipc_requests.deleteMany({
+            where: { thread_id: 'ipc-test-thread' },
+        });
+        await prisma.thread_sessions.delete({
+            where: { thread_id: 'ipc-test-thread' },
+        });
+    }, 30_000);
+    test('interactive $transaction (callback form)', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        // Interactive transaction: reads and writes within the same tx callback.
+        // This exercises BEGIN/queries/COMMIT across multiple hrana pipeline
+        // requests with batons (stream continuity).
+        const result = await prisma.$transaction(async (tx) => {
+            await tx.thread_sessions.create({
+                data: { thread_id: 'tx-interactive-1', session_id: 'sess-tx-1' },
+            });
+            await tx.thread_sessions.create({
+                data: { thread_id: 'tx-interactive-2', session_id: 'sess-tx-2' },
+            });
+            // Read inside the same transaction — should see uncommitted rows
+            const count = await tx.thread_sessions.count({
+                where: { thread_id: { startsWith: 'tx-interactive-' } },
+            });
+            // Conditional write based on read
+            if (count === 2) {
+                await tx.thread_sessions.update({
+                    where: { thread_id: 'tx-interactive-1' },
+                    data: { session_id: 'sess-tx-1-updated' },
+                });
+            }
+            return tx.thread_sessions.findMany({
+                where: { thread_id: { startsWith: 'tx-interactive-' } },
+                orderBy: { thread_id: 'asc' },
+                select: { thread_id: true, session_id: true },
+            });
+        });
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "session_id": "sess-tx-1-updated",
+          "thread_id": "tx-interactive-1",
+        },
+        {
+          "session_id": "sess-tx-2",
+          "thread_id": "tx-interactive-2",
+        },
+      ]
+    `);
+        // Verify committed outside transaction
+        const outside = await prisma.thread_sessions.count({
+            where: { thread_id: { startsWith: 'tx-interactive-' } },
+        });
+        expect(outside).toBe(2);
+        // Cleanup
+        await prisma.thread_sessions.deleteMany({
+            where: { thread_id: { startsWith: 'tx-interactive-' } },
+        });
+    }, 30_000);
+    test('interactive $transaction rolls back on error', async () => {
+        if (!prisma)
+            throw new Error('prisma not initialized');
+        // Verify rollback: if the callback throws, no rows should be committed
+        const txError = await prisma
+            .$transaction(async (tx) => {
+            await tx.thread_sessions.create({
+                data: { thread_id: 'tx-rollback-1', session_id: 'sess-rollback' },
+            });
+            throw new Error('intentional rollback');
+        })
+            .catch((e) => e);
+        expect(txError).toBeInstanceOf(Error);
+        expect(txError.message).toContain('intentional rollback');
+        // Row should NOT exist — transaction was rolled back
+        const ghost = await prisma.thread_sessions.findUnique({
+            where: { thread_id: 'tx-rollback-1' },
+        });
+        expect(ghost).toBeNull();
+    }, 30_000);
+});

package/dist/html-actions.js

@@ -0,0 +1,123 @@
+// HTML action registry for rendered Discord components.
+// Stores short-lived button callbacks by generated id so HTML-backed UI can
+// attach interactions without leaking closures across rerenders.
+import crypto from 'node:crypto';
+import { ComponentType, MessageFlags, } from 'discord.js';
+import { createLogger } from './logger.js';
+import { notifyError } from './sentry.js';
+const logger = createLogger('HTML_ACT');
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+export const pendingHtmlActions = new Map();
+const actionIdsByOwner = new Map();
+export function buildHtmlActionCustomId(actionId) {
+    return `html_action:${actionId}`;
+}
+export function registerHtmlAction({ ownerKey, threadId, run, ttlMs = DEFAULT_TTL_MS, }) {
+    const actionId = crypto.randomBytes(8).toString('hex');
+    const timer = setTimeout(() => {
+        resolveHtmlAction({ actionId });
+    }, ttlMs);
+    pendingHtmlActions.set(actionId, {
+        actionId,
+        ownerKey,
+        threadId,
+        resolved: false,
+        timer,
+        run,
+    });
+    const ownerActionIds = actionIdsByOwner.get(ownerKey) ?? new Set();
+    ownerActionIds.add(actionId);
+    actionIdsByOwner.set(ownerKey, ownerActionIds);
+    return actionId;
+}
+export function cancelHtmlActionsForOwner(ownerKey) {
+    const actionIds = actionIdsByOwner.get(ownerKey);
+    if (!actionIds) {
+        return 0;
+    }
+    let cancelled = 0;
+    for (const actionId of actionIds) {
+        const resolved = resolveHtmlAction({ actionId });
+        if (!resolved) {
+            continue;
+        }
+        cancelled++;
+    }
+    return cancelled;
+}
+export function cancelHtmlActionsForThread(threadId) {
+    let cancelled = 0;
+    for (const [actionId, action] of pendingHtmlActions) {
+        if (action.threadId !== threadId) {
+            continue;
+        }
+        const resolved = resolveHtmlAction({ actionId });
+        if (!resolved) {
+            continue;
+        }
+        cancelled++;
+    }
+    return cancelled;
+}
+export async function handleHtmlActionButton(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('html_action:')) {
+        return;
+    }
+    const actionId = customId.slice('html_action:'.length);
+    if (!actionId) {
+        await interaction.reply({
+            content: 'Invalid action button.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const action = pendingHtmlActions.get(actionId);
+    if (!action || action.resolved) {
+        await interaction.reply({
+            content: 'This action is no longer available.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferUpdate();
+    const resolvedAction = resolveHtmlAction({ actionId });
+    if (!resolvedAction) {
+        return;
+    }
+    try {
+        await resolvedAction.run({ interaction });
+    }
+    catch (error) {
+        logger.error('[HTML_ACTION] Failed to run action:', error);
+        void notifyError(error, 'HTML action button failed');
+        await interaction
+            .editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: `Action failed: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        })
+            .catch(() => {
+            return undefined;
+        });
+    }
+}
+function resolveHtmlAction({ actionId, }) {
+    const action = pendingHtmlActions.get(actionId);
+    if (!action || action.resolved) {
+        return undefined;
+    }
+    action.resolved = true;
+    clearTimeout(action.timer);
+    pendingHtmlActions.delete(actionId);
+    const ownerActionIds = actionIdsByOwner.get(action.ownerKey);
+    ownerActionIds?.delete(actionId);
+    if (ownerActionIds && ownerActionIds.size === 0) {
+        actionIdsByOwner.delete(action.ownerKey);
+    }
+    return action;
+}

package/dist/html-actions.test.js

@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, test } from 'vitest';
+import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, cancelHtmlActionsForThread, pendingHtmlActions, registerHtmlAction, } from './html-actions.js';
+const TEST_OWNER_A = 'worktrees:user-a:channel-a';
+const TEST_OWNER_B = 'worktrees:user-b:channel-a';
+afterEach(() => {
+    cancelHtmlActionsForOwner(TEST_OWNER_A);
+    cancelHtmlActionsForOwner(TEST_OWNER_B);
+});
+describe('html action registry', () => {
+    test('registers action ids with expected custom id prefix', () => {
+        const actionId = registerHtmlAction({
+            ownerKey: TEST_OWNER_A,
+            run: async () => {
+                return undefined;
+            },
+        });
+        expect(buildHtmlActionCustomId(actionId)).toMatch(/^html_action:/);
+        expect(pendingHtmlActions.has(actionId)).toBe(true);
+    });
+    test('cancels actions by owner', () => {
+        registerHtmlAction({
+            ownerKey: TEST_OWNER_A,
+            run: async () => {
+                return undefined;
+            },
+        });
+        registerHtmlAction({
+            ownerKey: TEST_OWNER_A,
+            run: async () => {
+                return undefined;
+            },
+        });
+        expect(cancelHtmlActionsForOwner(TEST_OWNER_A)).toBe(2);
+        expect(pendingHtmlActions.size).toBe(0);
+    });
+    test('cancels only actions from the matching thread', () => {
+        const threadAActionId = registerHtmlAction({
+            ownerKey: TEST_OWNER_A,
+            threadId: 'thread-a',
+            run: async () => {
+                return undefined;
+            },
+        });
+        const threadBActionId = registerHtmlAction({
+            ownerKey: TEST_OWNER_B,
+            threadId: 'thread-b',
+            run: async () => {
+                return undefined;
+            },
+        });
+        expect(cancelHtmlActionsForThread('thread-a')).toBe(1);
+        expect(pendingHtmlActions.has(threadAActionId)).toBe(false);
+        expect(pendingHtmlActions.has(threadBActionId)).toBe(true);
+    });
+    test('expires actions after ttl', async () => {
+        const actionId = registerHtmlAction({
+            ownerKey: TEST_OWNER_A,
+            ttlMs: 10,
+            run: async () => {
+                return undefined;
+            },
+        });
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, 30);
+        });
+        expect(pendingHtmlActions.has(actionId)).toBe(false);
+    });
+});

package/dist/html-components.js

@@ -0,0 +1,117 @@
+// HTML fragment parser for Discord-renderable components.
+// Supports a small reusable subset today (text + button) so tables and other
+// CV2 renderers can map inline HTML into Discord UI elements.
+import { DomHandler, ElementType, Parser } from 'htmlparser2';
+export function parseInlineHtmlRenderables({ html, }) {
+    let parseError;
+    let domNodes = [];
+    const handler = new DomHandler((error, dom) => {
+        if (error) {
+            parseError = new Error('Failed to parse HTML fragment', {
+                cause: error,
+            });
+            return;
+        }
+        domNodes = dom;
+    }, {
+        withStartIndices: false,
+        withEndIndices: false,
+    });
+    const parser = new Parser(handler, {
+        xmlMode: false,
+        decodeEntities: false,
+        recognizeSelfClosing: true,
+    });
+    parser.write(html);
+    parser.end();
+    if (parseError) {
+        return parseError;
+    }
+    return parseRenderableNodes({ nodes: domNodes });
+}
+function parseRenderableNodes({ nodes, }) {
+    const renderables = [];
+    for (const node of nodes) {
+        if (node.type === ElementType.Text) {
+            const textNode = node;
+            renderables.push({
+                type: 'text',
+                text: textNode.data,
+            });
+            continue;
+        }
+        if (node.type === ElementType.Tag) {
+            const element = node;
+            if (element.name !== 'button') {
+                return new Error(`Unsupported HTML tag: <${element.name}>`);
+            }
+            const buttonRenderable = parseButtonElement({ element });
+            if (buttonRenderable instanceof Error) {
+                return buttonRenderable;
+            }
+            renderables.push(buttonRenderable);
+            continue;
+        }
+        if (node.type === ElementType.Comment) {
+            continue;
+        }
+        return new Error(`Unsupported HTML node type: ${node.type}`);
+    }
+    return renderables;
+}
+function parseButtonElement({ element, }) {
+    const id = element.attribs.id?.trim();
+    if (!id) {
+        return new Error('<button> is missing required id attribute');
+    }
+    const label = extractNodeText({ nodes: element.children })
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!label) {
+        return new Error(`<button id="${id}"> is missing label text`);
+    }
+    const variant = normalizeButtonVariant({
+        value: element.attribs.variant,
+    });
+    if (variant instanceof Error) {
+        return variant;
+    }
+    return {
+        type: 'button',
+        id,
+        label,
+        variant,
+        disabled: 'disabled' in element.attribs,
+    };
+}
+function normalizeButtonVariant({ value, }) {
+    if (!value) {
+        return 'secondary';
+    }
+    if (value === 'secondary') {
+        return value;
+    }
+    if (value === 'primary') {
+        return value;
+    }
+    if (value === 'success') {
+        return value;
+    }
+    if (value === 'danger') {
+        return value;
+    }
+    return new Error(`Unsupported <button> variant: ${value}`);
+}
+function extractNodeText({ nodes, }) {
+    const parts = [];
+    for (const node of nodes) {
+        if (node.type === ElementType.Text) {
+            parts.push(node.data);
+            continue;
+        }
+        if (node.type === ElementType.Tag) {
+            parts.push(extractNodeText({ nodes: node.children }));
+        }
+    }
+    return parts.join('');
+}