toiljs 0.0.115 → 0.0.117

package/test/dom/revalidate.test.tsx

@@ -1,38 +0,0 @@
-// @vitest-environment jsdom
-import { act, cleanup, render } from '@testing-library/react';
-import { afterEach, beforeEach, describe, it } from 'vitest';
-
-import { Router } from '../../src/client/routing/Router';
-import { clearLoaderData, revalidate, useLoaderData } from '../../src/client/routing/loader';
-import type { RouteDef } from '../../src/client/types';
-
-afterEach(cleanup);
-beforeEach(() => {
-    clearLoaderData();
-    window.history.replaceState({}, '', '/');
-});
-
-describe('revalidate refetches', () => {
-    it('re-runs the loader and updates the rendered data', async () => {
-        let n = 0;
-        function Page(): React.ReactNode {
-            const value = useLoaderData<number>();
-            return <p>val:{String(value)}</p>;
-        }
-        const routes: RouteDef[] = [
-            {
-                pattern: '/',
-                load: () => Promise.resolve({ default: Page, loader: () => (n += 1) }),
-                // matches the example: this route has a loading.tsx (keyed boundary + transition).
-                loading: () => Promise.resolve({ default: () => <p>loading</p> }),
-            },
-        ];
-        const { findByText } = render(<Router routes={routes} />);
-        await findByText('val:1');
-
-        act(() => {
-            revalidate();
-        });
-        await findByText('val:2');
-    });
-});

package/test/dom/route-head.test.tsx

@@ -1,56 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { setRouteHead, useHead } from '../../src/client/head/head';
-import { resolveMetadata } from '../../src/client/head/metadata';
-import { cleanup, render } from '@testing-library/react';
-
-afterEach(() => {
-    cleanup();
-    setRouteHead(null);
-});
-
-const desc = (): string | null =>
-    document.head.querySelector('meta[name="description"]')?.getAttribute('content') ?? null;
-
-describe('route head (metadata baseline)', () => {
-    it('applies a resolved metadata head to the document', () => {
-        setRouteHead(resolveMetadata({ title: 'About', description: 'about page' }));
-        expect(document.title).toBe('About');
-        expect(desc()).toBe('about page');
-    });
-
-    it("wins over a layout's useHead/<Head> defaults for the keys it sets", () => {
-        // A layout default title + a route's metadata title: the route metadata should win.
-        function LayoutDefaults() {
-            useHead({ title: 'Site Default', meta: [{ name: 'description', content: 'site' }] });
-            return null;
-        }
-        render(<LayoutDefaults />);
-        setRouteHead(resolveMetadata({ title: 'useReducer', description: 'route desc' }));
-        expect(document.title).toBe('useReducer');
-        expect(desc()).toBe('route desc');
-    });
-
-    // Regression for the "metadata title doesn't update" report: a real layout (title default)
-    // plus a route's full `metadata` (the exact shape users write) must land on the route's title,
-    // with the route's og:title applied too.
-    it('applies a full route metadata over a layout title default', () => {
-        function LayoutDefaults() {
-            useHead({ title: 'ToilJS' });
-            return null;
-        }
-        render(<LayoutDefaults />);
-        setRouteHead(
-            resolveMetadata({
-                title: 'useReducer | React Hooks',
-                description: 'Manage complex state with a reducer.',
-                openGraph: { title: 'useReducer | React Hooks', type: 'website' },
-            }),
-        );
-        expect(document.title).toBe('useReducer | React Hooks');
-        expect(
-            document.head.querySelector('meta[property="og:title"]')?.getAttribute('content'),
-        ).toBe('useReducer | React Hooks');
-    });
-});

package/test/dom/router-loading.test.tsx

@@ -1,44 +0,0 @@
-// @vitest-environment jsdom
-import { act, cleanup, render, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { navigate } from '../../src/client/navigation/navigation';
-import { Router } from '../../src/client/routing/Router';
-import type { RouteDef } from '../../src/client/types';
-
-afterEach(cleanup);
-beforeEach(() => {
-    window.history.replaceState({}, '', '/');
-});
-
-const routes: RouteDef[] = [
-    {
-        pattern: '/',
-        load: () => Promise.resolve({ default: () => <div>HOME</div> }),
-    },
-    {
-        // Page chunk never resolves, so the route stays suspended, exercising the fallback path.
-        pattern: '/slow',
-        load: () => new Promise<{ default: () => null }>(() => undefined),
-        loading: () => Promise.resolve({ default: () => <div>LOADING</div> }),
-    },
-];
-
-describe('Router loading fallback', () => {
-    it("shows the route's loading.tsx immediately when navigating to a suspending route", async () => {
-        const { findByText, queryByText } = render(<Router routes={routes} />);
-        await findByText('HOME');
-
-        // A route with a `loading.tsx` keys its Suspense boundary per URL, so even though navigation
-        // runs in a transition the fallback appears immediately (it isn't suppressed / frozen).
-        act(() => {
-            navigate('/slow');
-        });
-
-        await waitFor(() => {
-            expect(queryByText('LOADING')).not.toBeNull();
-        });
-        // The keyed boundary remounts for the new route, so the previous page is gone (not frozen).
-        expect(queryByText('HOME')).toBeNull();
-    });
-});

package/test/dom/scroll.test.ts

@@ -1,56 +0,0 @@
-// @vitest-environment jsdom
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import {
-    applyScroll,
-    enableManualScrollRestoration,
-    planScroll,
-    rememberScroll,
-} from '../../src/client/navigation/scroll';
-
-beforeEach(() => {
-    window.scrollTo = vi.fn();
-    Object.defineProperty(window, 'scrollY', { value: 0, configurable: true });
-});
-
-describe('scroll management', () => {
-    it('enables manual scroll restoration when the browser supports it', () => {
-        // jsdom doesn't implement scrollRestoration; define it so the guarded branch runs.
-        (window.history as History & { scrollRestoration: ScrollRestoration }).scrollRestoration =
-            'auto';
-        enableManualScrollRestoration();
-        expect(window.history.scrollRestoration).toBe('manual');
-    });
-
-    it('scrolls to top', () => {
-        planScroll({ hash: '', toTop: true });
-        applyScroll();
-        expect(window.scrollTo).toHaveBeenCalledWith(0, 0);
-    });
-
-    it('restores a saved position', () => {
-        Object.defineProperty(window, 'scrollY', { value: 250, configurable: true });
-        rememberScroll('k1');
-        planScroll({ restoreKey: 'k1', hash: '', toTop: false });
-        applyScroll();
-        expect(window.scrollTo).toHaveBeenCalledWith(0, 250);
-    });
-
-    it('scrolls to a #hash element', () => {
-        const el = document.createElement('div');
-        el.id = 'sec';
-        el.scrollIntoView = vi.fn();
-        document.body.appendChild(el);
-        planScroll({ hash: '#sec', toTop: false });
-        applyScroll();
-        expect(el.scrollIntoView).toHaveBeenCalled();
-    });
-
-    it('consumes the plan (second applyScroll is a no-op)', () => {
-        planScroll({ hash: '', toTop: true });
-        applyScroll();
-        (window.scrollTo as ReturnType<typeof vi.fn>).mockClear();
-        applyScroll();
-        expect(window.scrollTo).not.toHaveBeenCalled();
-    });
-});

package/test/dom/slot.test.tsx

@@ -1,131 +0,0 @@
-// @vitest-environment jsdom
-import { act, cleanup, render } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import type { ReactNode } from 'react';
-
-import { Slot } from '../../src/client/components/Slot';
-import { navigate } from '../../src/client/navigation/navigation';
-import { Router } from '../../src/client/routing/Router';
-import { clearLoaderData } from '../../src/client/routing/loader';
-import { SlotContext } from '../../src/client/routing/slot-context';
-import type { RouteDef } from '../../src/client/types';
-
-const layoutWithModal = () =>
-    Promise.resolve({
-        default: ({ children }: { children?: ReactNode }) => (
-            <div>
-                {children}
-                <Slot name="modal" />
-            </div>
-        ),
-    });
-
-afterEach(cleanup);
-beforeEach(() => {
-    clearLoaderData();
-    window.history.replaceState({}, '', '/');
-});
-
-describe('Slot', () => {
-    it('renders the named slot element from context, or the fallback', () => {
-        const { getByText, queryByText } = render(
-            <SlotContext.Provider value={{ modal: <span>MODAL</span> }}>
-                <Slot name="modal" />
-                <Slot
-                    name="missing"
-                    fallback={<span>FB</span>}
-                />
-            </SlotContext.Provider>,
-        );
-        expect(getByText('MODAL')).toBeTruthy();
-        expect(getByText('FB')).toBeTruthy();
-        expect(queryByText('missing')).toBeNull();
-    });
-});
-
-describe('Router parallel slots', () => {
-    const routes: RouteDef[] = [
-        { pattern: '/', load: () => Promise.resolve({ default: () => <main>PAGE</main> }) },
-    ];
-    // A layout that renders the page plus the "modal" slot.
-    const layout = () =>
-        Promise.resolve({
-            default: ({ children }: { children?: ReactNode }) => (
-                <div>
-                    {children}
-                    <Slot name="modal" />
-                </div>
-            ),
-        });
-    const slots: Record<string, RouteDef[]> = {
-        modal: [
-            { pattern: '/', load: () => Promise.resolve({ default: () => <aside>SLOT</aside> }) },
-        ],
-    };
-
-    it('renders the main route and a matching slot together', async () => {
-        const { findByText } = render(
-            <Router
-                routes={routes}
-                layout={layout}
-                slots={slots}
-            />,
-        );
-        // Both the page and the parallel slot render for the same URL.
-        await findByText('PAGE');
-        await findByText('SLOT');
-    });
-});
-
-describe('intercepting routes', () => {
-    const routes: RouteDef[] = [
-        {
-            pattern: '/photo/:id',
-            load: () => Promise.resolve({ default: () => <main>PHOTO PAGE</main> }),
-        },
-        { pattern: '/', load: () => Promise.resolve({ default: () => <main>FEED</main> }) },
-    ];
-    const slots: Record<string, RouteDef[]> = {
-        modal: [
-            {
-                pattern: '/photo/:id',
-                intercept: true,
-                load: () => Promise.resolve({ default: () => <aside>PHOTO MODAL</aside> }),
-            },
-        ],
-    };
-
-    // This test must run before any navigation so it observes a "hard" load (soft-nav state is false).
-    it('shows the full page on a hard load (no interception)', async () => {
-        window.history.replaceState({}, '', '/photo/1');
-        const { findByText, queryByText } = render(
-            <Router
-                routes={routes}
-                layout={layoutWithModal}
-                slots={slots}
-            />,
-        );
-        await findByText('PHOTO PAGE');
-        expect(queryByText('PHOTO MODAL')).toBeNull();
-    });
-
-    it('intercepts on soft navigation: modal overlays, previous page stays', async () => {
-        window.history.replaceState({}, '', '/');
-        const { findByText, queryByText } = render(
-            <Router
-                routes={routes}
-                layout={layoutWithModal}
-                slots={slots}
-            />,
-        );
-        await findByText('FEED');
-        act(() => {
-            navigate('/photo/1');
-        });
-        // The intercepting slot route shows the modal…
-        await findByText('PHOTO MODAL');
-        // …while the main view keeps the previous page (the backdrop), not the full photo page.
-        expect(queryByText('FEED')).not.toBeNull();
-        expect(queryByText('PHOTO PAGE')).toBeNull();
-    });
-});

package/test/dom/use-metadata.test.tsx

@@ -1,58 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it } from 'vitest';
-import { cleanup, render } from '@testing-library/react';
-
-import { Metadata, useMetadata } from '../../src/client/head/metadata';
-import { setRouteHead } from '../../src/client/head/head';
-
-afterEach(() => {
-    cleanup();
-    setRouteHead(null);
-});
-
-const meta = (key: string): string | null =>
-    document.head.querySelector(`meta[${key}]`)?.getAttribute('content') ?? null;
-
-describe('useMetadata / <Metadata>', () => {
-    it('applies a full Metadata object to the document head from a component', () => {
-        function Article() {
-            useMetadata({
-                title: 'Article',
-                description: 'an article',
-                openGraph: { title: 'og title', type: 'website' },
-            });
-            return null;
-        }
-        render(<Article />);
-        expect(document.title).toBe('Article');
-        expect(meta('name="description"')).toBe('an article');
-        expect(meta('property="og:title"')).toBe('og title');
-    });
-
-    it('reverts the head when the component unmounts', () => {
-        function Article() {
-            useMetadata({ title: 'Temp' });
-            return null;
-        }
-        const { unmount } = render(<Article />);
-        expect(document.title).toBe('Temp');
-        unmount();
-        expect(document.title).not.toBe('Temp');
-    });
-
-    it('the declarative <Metadata> form applies too', () => {
-        render(<Metadata title="Declarative" />);
-        expect(document.title).toBe('Declarative');
-    });
-
-    it("a route's metadata still wins over a component's useMetadata", () => {
-        function Article() {
-            useMetadata({ title: 'Component' });
-            return null;
-        }
-        render(<Article />);
-        // The route baseline (applied last) takes precedence for keys it sets.
-        setRouteHead({ title: 'Route' });
-        expect(document.title).toBe('Route');
-    });
-});

package/test/dom/view-transitions.test.tsx

@@ -1,53 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { navigate, setViewTransitions } from '../../src/client/navigation/navigation';
-
-interface VTDoc {
-    startViewTransition?: (cb: () => void) => unknown;
-}
-const doc = document as Document & VTDoc;
-
-afterEach(() => {
-    setViewTransitions(false);
-    delete doc.startViewTransition;
-    vi.restoreAllMocks();
-    window.history.replaceState({}, '', '/');
-});
-
-describe('view transitions', () => {
-    function stubReducedMotion(matches: boolean): void {
-        window.matchMedia = vi
-            .fn()
-            .mockReturnValue({ matches }) as unknown as typeof window.matchMedia;
-    }
-
-    it('wraps navigation in startViewTransition when enabled and supported', () => {
-        const vt = vi.fn((cb: () => void) => {
-            cb();
-        });
-        doc.startViewTransition = vt;
-        stubReducedMotion(false);
-        setViewTransitions(true);
-        navigate('/a');
-        expect(vt).toHaveBeenCalledOnce();
-    });
-
-    it('skips the view transition under prefers-reduced-motion', () => {
-        const vt = vi.fn();
-        doc.startViewTransition = vt;
-        stubReducedMotion(true);
-        setViewTransitions(true);
-        navigate('/b');
-        expect(vt).not.toHaveBeenCalled();
-    });
-
-    it('does not use view transitions when disabled', () => {
-        const vt = vi.fn();
-        doc.startViewTransition = vt;
-        stubReducedMotion(false);
-        setViewTransitions(false);
-        navigate('/c');
-        expect(vt).not.toHaveBeenCalled();
-    });
-});

package/test/dynamic-routing.test.ts

@@ -1,132 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import ts from 'typescript';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { exportsTrue } from '../src/compiler/prerender';
-import { patternToBracketFile, staticSectionPattern } from '../src/compiler/routes';
-import { resolveDynamicFile } from '../src/devserver/http/runtime';
-
-describe('patternToBracketFile', () => {
-    it('inverts URL patterns back to on-disk bracket filenames', () => {
-        expect(patternToBracketFile('/blog/:id')).toBe('blog/[id].html');
-        expect(patternToBracketFile('/docs/*slug')).toBe('docs/[...slug].html');
-        expect(patternToBracketFile('/docs/**slug')).toBe('docs/[[...slug]].html');
-        expect(patternToBracketFile('/:category/:id')).toBe('[category]/[id].html');
-        expect(patternToBracketFile('/gallery/photo/:id')).toBe('gallery/photo/[id].html');
-    });
-});
-
-describe('staticSectionPattern', () => {
-    it('strips dynamic segments to the static section (for the template canonical)', () => {
-        expect(staticSectionPattern('/blog/:id')).toBe('/blog');
-        expect(staticSectionPattern('/docs/*slug')).toBe('/docs');
-        expect(staticSectionPattern('/:category/:id')).toBe('/');
-        expect(staticSectionPattern('/gallery/photo/:id')).toBe('/gallery/photo');
-    });
-});
-
-describe('exportsTrue (edge-SSR opt-in detection)', () => {
-    const files: string[] = [];
-    function tmp(source: string): string {
-        const file = path.join(os.tmpdir(), `toil-ssrflag-${String(files.length)}-${process.pid}.tsx`);
-        fs.writeFileSync(file, source);
-        files.push(file);
-        return file;
-    }
-    afterEach(() => {
-        for (const f of files.splice(0)) fs.rmSync(f, { force: true });
-    });
-
-    it('detects `export const ssr = true`', () => {
-        expect(exportsTrue(ts, tmp(`export const ssr = true;\nexport default () => null;\n`), 'ssr')).toBe(
-            true,
-        );
-    });
-    it('is false for ssr=false, a non-literal, or an absent export', () => {
-        expect(exportsTrue(ts, tmp(`export const ssr = false;\n`), 'ssr')).toBe(false);
-        expect(exportsTrue(ts, tmp(`const ssr = true;\n`), 'ssr')).toBe(false); // not exported
-        expect(exportsTrue(ts, tmp(`export const other = true;\n`), 'ssr')).toBe(false);
-    });
-});
-
-describe('resolveDynamicFile (self-host bracket routing, mirrors the edge)', () => {
-    const roots: string[] = [];
-    function siteRoot(): string {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-dyn-'));
-        roots.push(root);
-        return root;
-    }
-    function write(root: string, rel: string, body = '<html></html>'): void {
-        const full = path.join(root, rel);
-        fs.mkdirSync(path.dirname(full), { recursive: true });
-        fs.writeFileSync(full, body);
-    }
-    afterEach(() => {
-        for (const d of roots.splice(0)) fs.rmSync(d, { recursive: true, force: true });
-    });
-
-    it('serves a single-segment [id].html for a matching URL, one segment only', () => {
-        const root = siteRoot();
-        write(root, 'blog/[id].html', 'blog-shell');
-        expect(resolveDynamicFile(root, '/blog/hello')).toBe(path.join(root, 'blog/[id].html'));
-        expect(resolveDynamicFile(root, '/blog/a/b')).toBeNull();
-    });
-
-    it('serves a required catch-all for 1+ segments but not zero', () => {
-        const root = siteRoot();
-        write(root, 'docs/[...slug].html', 'docs');
-        expect(resolveDynamicFile(root, '/docs/a')).toBe(path.join(root, 'docs/[...slug].html'));
-        expect(resolveDynamicFile(root, '/docs/a/b/c')).toBe(path.join(root, 'docs/[...slug].html'));
-        expect(resolveDynamicFile(root, '/docs')).toBeNull();
-        // Parity with the client router + edge: a literal `index.html` segment is a slug (matches
-        // the catch-all), while a bare `/docs/` is zero trailing segments (no required-catch-all match).
-        expect(resolveDynamicFile(root, '/docs/index.html')).toBe(
-            path.join(root, 'docs/[...slug].html'),
-        );
-        expect(resolveDynamicFile(root, '/docs/')).toBeNull();
-    });
-
-    it('serves an optional catch-all for 0+ segments', () => {
-        const root = siteRoot();
-        write(root, 'files/[[...slug]].html', 'files');
-        expect(resolveDynamicFile(root, '/files')).toBe(path.join(root, 'files/[[...slug]].html'));
-        expect(resolveDynamicFile(root, '/files/a/b')).toBe(path.join(root, 'files/[[...slug]].html'));
-    });
-
-    it('prefers single over catch-all for one segment, catch-all for deeper', () => {
-        const root = siteRoot();
-        write(root, 'shop/[id].html', 'one');
-        write(root, 'shop/[...rest].html', 'many');
-        expect(fs.readFileSync(resolveDynamicFile(root, '/shop/x') as string, 'utf8')).toBe('one');
-        expect(fs.readFileSync(resolveDynamicFile(root, '/shop/x/y') as string, 'utf8')).toBe('many');
-    });
-
-    it('prefers a real static subdirectory over a dynamic sibling', () => {
-        const root = siteRoot();
-        write(root, 'blog/[id].html', 'template');
-        write(root, 'blog/about/deep/[id].html', 'deep');
-        // /blog/about/deep/7 descends the real dirs to the deep template, not blog/[id].html.
-        expect(resolveDynamicFile(root, '/blog/about/deep/7')).toBe(
-            path.join(root, 'blog/about/deep/[id].html'),
-        );
-    });
-
-    it('resolves a nested bracket directory', () => {
-        const root = siteRoot();
-        write(root, '[category]/[id].html', 'cat');
-        expect(resolveDynamicFile(root, '/electronics/9')).toBe(
-            path.join(root, '[category]/[id].html'),
-        );
-        expect(resolveDynamicFile(root, '/electronics')).toBeNull();
-    });
-
-    it('returns null when no bracket template exists', () => {
-        const root = siteRoot();
-        write(root, 'about/index.html', 'about');
-        expect(resolveDynamicFile(root, '/blog/foo')).toBeNull();
-        expect(resolveDynamicFile(root, '/x/y/z')).toBeNull();
-    });
-});

package/test/email-console.test.ts

@@ -1,86 +0,0 @@
-/**
- * Dev email emulator (src/devserver/email/console.ts): the ASCII-drawn box + the
- * HTML->text conversion + action (link/code) extraction that make confirm/reset/2FA
- * flows testable in `toiljs dev` without a real inbox.
- */
-import { describe, expect, it } from 'vitest';
-
-import {
-    emailAction,
-    htmlToText,
-    parseColor,
-    renderEmailConsole,
-    renderHtmlBody,
-} from '../src/devserver/email/console.js';
-
-const confirmEmail = {
-    to: 'bob@gmail.com',
-    subject: 'Confirm your account',
-    purpose: 'verify',
-    body: 'Confirm your account by opening this link:\nhttp://localhost:3000/confirm#token=abc123\n',
-    html:
-        '<p>Confirm your account by clicking the link below:</p>' +
-        '<p><a href="http://localhost:3000/confirm#token=abc123">Confirm my account</a></p>',
-};
-
-/** picocolors may or may not emit ANSI depending on TTY; strip it for assertions. */
-const plain = (s: string): string => s.replace(/\[[0-9;]*m/g, '');
-
-describe('dev email emulator', () => {
-    it('htmlToText: anchors become "text (url)", blocks become newlines, entities decode', () => {
-        const t = htmlToText('<p>Hi &amp; welcome</p><p><a href="https://x.com/a?b=1">Open</a></p>');
-        expect(t).toContain('Hi & welcome');
-        expect(t).toContain('Open (https://x.com/a?b=1)');
-    });
-
-    it('emailAction extracts the link from a confirm email', () => {
-        expect(emailAction(confirmEmail)).toEqual({
-            kind: 'link',
-            value: 'http://localhost:3000/confirm#token=abc123',
-        });
-    });
-
-    it('emailAction extracts a 2FA code when there is no link', () => {
-        const twofa = { to: 'x', subject: 's', purpose: '2fa', body: 'Your code is 481920.', html: '' };
-        expect(emailAction(twofa)).toEqual({ kind: 'code', value: '481920' });
-    });
-
-    it('emailAction falls back to the HTML body when the text body is empty', () => {
-        expect(emailAction({ ...confirmEmail, body: '' })?.value).toBe(
-            'http://localhost:3000/confirm#token=abc123',
-        );
-    });
-
-    it('renderEmailConsole draws a box with recipient, subject, and the clickable link', () => {
-        const box = plain(renderEmailConsole(confirmEmail, 'not sent'));
-        expect(box).toContain('bob@gmail.com');
-        expect(box).toContain('Confirm your account');
-        expect(box).toContain('http://localhost:3000/confirm#token=abc123');
-        expect(box).toContain('┌');
-        expect(box).toContain('└');
-    });
-
-    it('parseColor: hex, short hex, rgb, and named colors', () => {
-        expect(parseColor('#ff0000')).toEqual([255, 0, 0]);
-        expect(parseColor('#0f0')).toEqual([0, 255, 0]);
-        expect(parseColor('rgb(10, 20, 30)')).toEqual([10, 20, 30]);
-        expect(parseColor('red')).toEqual([229, 57, 53]);
-        expect(parseColor('not-a-color')).toBeUndefined();
-    });
-
-    it('renderHtmlBody: keeps text + link, splits paragraphs, wraps to width', () => {
-        const lines = renderHtmlBody(
-            '<p>Hi <b>there</b> &amp; welcome</p>' +
-                '<p><a href="https://x.com/a?b=1">Open</a></p>',
-            40,
-        );
-        const joined = lines.map((l) => l.replace(/\x1b\[[0-9;]*m/g, '')).join('\n');
-        expect(joined).toContain('Hi there & welcome');
-        expect(joined).toContain('Open');
-        expect(joined).toContain('(https://x.com/a?b=1)');
-        // a blank separator line sits between the two paragraphs
-        expect(lines).toContain('');
-        // no line exceeds the wrap width (visible chars; color is off under vitest)
-        for (const l of lines) expect(l.replace(/\x1b\[[0-9;]*m/g, '').length).toBeLessThanOrEqual(40);
-    });
-});