relay-ide 0.1.0

package/dist/test/sidebar-items.test.js

@@ -0,0 +1,164 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildSidebarItems } from '../frontend/src/lib/state/sidebar-items.js';
+// ─── Minimal mock helpers ────────────────────────────────────────────────────
+function makeSession(overrides) {
+    return {
+        type: 'agent',
+        agent: 'claude',
+        repoName: 'repo',
+        worktreePath: null,
+        cwd: overrides.repoPath,
+        branchName: 'main',
+        displayName: 'repo',
+        createdAt: '2026-01-01T00:00:00Z',
+        lastActivity: '2026-01-01T00:00:00Z',
+        idle: true,
+        agentState: 'idle',
+        ...overrides,
+    };
+}
+function makeWorktree(overrides) {
+    return {
+        name: 'worktree',
+        repoName: 'repo',
+        displayName: 'worktree',
+        lastActivity: '2026-01-01T00:00:00Z',
+        branchName: 'feature',
+        ...overrides,
+    };
+}
+function makeWorkspace(overrides) {
+    return {
+        name: overrides.path.split('/').at(-1) ?? 'workspace',
+        isGitRepo: true,
+        defaultBranch: 'main',
+        currentBranch: 'main',
+        ...overrides,
+    };
+}
+function makeItem(overrides) {
+    return {
+        kind: 'worktree',
+        path: overrides.id,
+        repoPath: '/repo',
+        displayName: 'item',
+        branchName: 'main',
+        lastActivity: '2026-01-01T00:00:00Z',
+        displayState: 'running',
+        lastKnownBackendState: 'running',
+        sessions: [],
+        ...overrides,
+    };
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+describe('buildSidebarItems', () => {
+    it('active session produces SidebarItem with that session', () => {
+        const session = makeSession({ id: 's1', repoPath: '/repo' });
+        const items = buildSidebarItems([session], [], [], []);
+        assert.equal(items.length, 1);
+        const item = items[0];
+        assert.equal(item.sessions.length, 1);
+        assert.notEqual(item.displayState, 'inactive');
+    });
+    it('inactive worktree (no sessions) produces SidebarItem with inactive state', () => {
+        const worktree = makeWorktree({ path: '/repo/wt1', repoPath: '/repo' });
+        const workspace = makeWorkspace({ path: '/repo' });
+        const items = buildSidebarItems([], [worktree], [workspace], []);
+        const wtItem = items.find((i) => i.id === '/repo/wt1');
+        assert.ok(wtItem, 'expected a SidebarItem for the worktree');
+        assert.equal(wtItem.displayState, 'inactive');
+        assert.equal(wtItem.sessions.length, 0);
+    });
+    it('workspace with no sessions produces repo-kind item with inactive state', () => {
+        const workspace = makeWorkspace({ path: '/repo' });
+        const items = buildSidebarItems([], [], [workspace], []);
+        assert.equal(items.length, 1);
+        const item = items[0];
+        assert.equal(item.kind, 'repo');
+        assert.equal(item.displayState, 'inactive');
+    });
+    it('two sessions with same worktreePath produce a single SidebarItem', () => {
+        const s1 = makeSession({
+            id: 's1',
+            repoPath: '/repo',
+            worktreePath: '/repo/wt1',
+        });
+        const s2 = makeSession({
+            id: 's2',
+            repoPath: '/repo',
+            worktreePath: '/repo/wt1',
+            branchName: 'feat',
+        });
+        const items = buildSidebarItems([s1, s2], [], [], []);
+        const grouped = items.filter((i) => i.id === '/repo/wt1');
+        assert.equal(grouped.length, 1);
+        assert.equal(grouped[0].sessions.length, 2);
+    });
+    it('workspace defaultBranch is used as branchName for inactive repo root', () => {
+        const workspace = makeWorkspace({
+            path: '/repo',
+            defaultBranch: 'feature-x',
+            currentBranch: null,
+        });
+        const items = buildSidebarItems([], [], [workspace], []);
+        assert.equal(items.length, 1);
+        assert.equal(items[0].branchName, 'feature-x');
+    });
+    it('reconciliation: seen-idle preserved when backend state unchanged', () => {
+        const session = makeSession({
+            id: 's1',
+            repoPath: '/repo',
+            idle: true,
+            agentState: 'idle',
+        });
+        const existing = makeItem({
+            id: '/repo',
+            kind: 'repo',
+            displayState: 'seen-idle',
+            lastKnownBackendState: 'idle',
+        });
+        const items = buildSidebarItems([session], [], [], [existing]);
+        const item = items.find((i) => i.id === '/repo');
+        assert.ok(item);
+        assert.equal(item.displayState, 'seen-idle');
+    });
+    it('reconciliation: running→idle backend change transitions displayState to unseen-idle', () => {
+        const session = makeSession({
+            id: 's1',
+            repoPath: '/repo',
+            idle: true,
+            agentState: 'idle',
+        });
+        // Existing item thinks backend is running; new data says idle
+        const existing = makeItem({
+            id: '/repo',
+            kind: 'repo',
+            displayState: 'running',
+            lastKnownBackendState: 'running',
+        });
+        const items = buildSidebarItems([session], [], [], [existing]);
+        const item = items.find((i) => i.id === '/repo');
+        assert.ok(item);
+        assert.equal(item.displayState, 'unseen-idle');
+    });
+    it('reconciliation: item with sessions that disappears becomes inactive', () => {
+        const existing = makeItem({
+            id: '/repo/wt1',
+            kind: 'worktree',
+            displayState: 'running',
+            lastKnownBackendState: 'running',
+            sessions: [
+                makeSession({ id: 's1', repoPath: '/repo', worktreePath: '/repo/wt1' }),
+            ],
+        });
+        // No sessions in new data
+        const workspace = makeWorkspace({ path: '/repo' });
+        const worktree = makeWorktree({ path: '/repo/wt1', repoPath: '/repo' });
+        const items = buildSidebarItems([], [worktree], [workspace], [existing]);
+        const item = items.find((i) => i.id === '/repo/wt1');
+        assert.ok(item);
+        assert.equal(item.displayState, 'inactive');
+        assert.equal(item.sessions.length, 0);
+    });
+});

package/dist/test/stores/boot-state-store.test.js

@@ -0,0 +1,165 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+// Mock localStorage before importing the store
+const storage = {};
+if (typeof globalThis.localStorage === 'undefined') {
+    Object.defineProperty(globalThis, 'localStorage', {
+        value: {
+            getItem: (key) => storage[key] ?? null,
+            setItem: (key, value) => { storage[key] = value; },
+            removeItem: (key) => { delete storage[key]; },
+            clear: () => { for (const key of Object.keys(storage))
+                delete storage[key]; },
+            get length() { return Object.keys(storage).length; },
+            key: (index) => Object.keys(storage)[index] ?? null,
+        },
+        configurable: true,
+    });
+}
+import { useBootStateStore } from '../../frontend/src/lib/stores/boot-state.js';
+function resetStore() {
+    useBootStateStore.setState({
+        phase: 'idle',
+        greeting: '',
+        lines: [],
+        bootComplete: false,
+    });
+}
+describe('boot-state Zustand store', () => {
+    beforeEach(() => {
+        resetStore();
+    });
+    describe('startBoot', () => {
+        it('transitions from idle to greeting', () => {
+            useBootStateStore.getState().startBoot();
+            const state = useBootStateStore.getState();
+            assert.strictEqual(state.phase, 'greeting');
+            assert.strictEqual(state.lines.length, 5);
+            assert.ok(state.greeting.length > 0, 'greeting should be non-empty');
+        });
+        it('creates 5 boot lines for all services', () => {
+            useBootStateStore.getState().startBoot();
+            const { lines } = useBootStateStore.getState();
+            assert.deepStrictEqual(lines.map((l) => l.service), ['auth', 'workspaces', 'sessions', 'worktrees', 'groups']);
+        });
+        it('all lines start as pending', () => {
+            useBootStateStore.getState().startBoot();
+            const { lines } = useBootStateStore.getState();
+            for (const line of lines) {
+                assert.strictEqual(line.status, 'pending');
+            }
+        });
+        it('is a no-op if already past idle', () => {
+            useBootStateStore.getState().startBoot();
+            const greetingAfterFirst = useBootStateStore.getState().greeting;
+            useBootStateStore.getState().startBoot();
+            assert.strictEqual(useBootStateStore.getState().phase, 'greeting');
+            assert.strictEqual(useBootStateStore.getState().greeting, greetingAfterFirst);
+        });
+    });
+    describe('reportFetch', () => {
+        beforeEach(() => {
+            useBootStateStore.getState().startBoot();
+        });
+        it('updates a known service to loading', () => {
+            useBootStateStore.getState().reportFetch('workspaces', 'loading');
+            const ws = useBootStateStore.getState().lines.find((l) => l.service === 'workspaces');
+            assert.strictEqual(ws.status, 'loading');
+        });
+        it('updates a service to ok with summary and duration', () => {
+            useBootStateStore.getState().reportFetch('sessions', 'ok', {
+                summary: '2 active',
+                durationMs: 42,
+            });
+            const sess = useBootStateStore.getState().lines.find((l) => l.service === 'sessions');
+            assert.strictEqual(sess.status, 'ok');
+            assert.strictEqual(sess.summary, '2 active');
+            assert.strictEqual(sess.durationMs, 42);
+        });
+        it('updates a service to fail with error', () => {
+            useBootStateStore.getState().reportFetch('worktrees', 'fail', {
+                error: 'timeout',
+                durationMs: 5000,
+            });
+            const wt = useBootStateStore.getState().lines.find((l) => l.service === 'worktrees');
+            assert.strictEqual(wt.status, 'fail');
+            assert.strictEqual(wt.error, 'timeout');
+            assert.strictEqual(wt.durationMs, 5000);
+        });
+        it('ignores unknown service', () => {
+            const linesBefore = [...useBootStateStore.getState().lines];
+            useBootStateStore.getState().reportFetch('unknown-service', 'ok');
+            assert.deepStrictEqual(useBootStateStore.getState().lines, linesBefore);
+        });
+        it('does not affect other lines', () => {
+            useBootStateStore.getState().reportFetch('auth', 'ok', { durationMs: 10 });
+            const { lines } = useBootStateStore.getState();
+            for (const line of lines) {
+                if (line.service !== 'auth') {
+                    assert.strictEqual(line.status, 'pending', `${line.service} should still be pending`);
+                }
+            }
+        });
+        it('transitions from greeting to booting on first non-auth loading', () => {
+            assert.strictEqual(useBootStateStore.getState().phase, 'greeting');
+            useBootStateStore.getState().reportFetch('workspaces', 'loading');
+            assert.strictEqual(useBootStateStore.getState().phase, 'booting');
+        });
+        it('does not transition to booting on auth loading', () => {
+            useBootStateStore.getState().reportFetch('auth', 'loading');
+            assert.strictEqual(useBootStateStore.getState().phase, 'greeting');
+        });
+    });
+    describe('finishBoot', () => {
+        beforeEach(() => {
+            useBootStateStore.getState().startBoot();
+        });
+        it('returns ready when all non-auth lines are ok', () => {
+            const { reportFetch } = useBootStateStore.getState();
+            reportFetch('auth', 'ok');
+            reportFetch('workspaces', 'ok', { summary: '3 repos' });
+            reportFetch('sessions', 'ok', { summary: '2 active' });
+            reportFetch('worktrees', 'ok', { summary: '1 tree' });
+            reportFetch('groups', 'ok', { summary: '0 groups' });
+            useBootStateStore.getState().finishBoot();
+            assert.strictEqual(useBootStateStore.getState().phase, 'ready');
+            assert.strictEqual(useBootStateStore.getState().bootComplete, true);
+        });
+        it('returns degraded when one fetch fails', () => {
+            const { reportFetch } = useBootStateStore.getState();
+            reportFetch('auth', 'ok');
+            reportFetch('workspaces', 'ok', { summary: '3 repos' });
+            reportFetch('sessions', 'fail', { error: 'timeout' });
+            reportFetch('worktrees', 'ok', { summary: '1 tree' });
+            reportFetch('groups', 'ok', { summary: '0 groups' });
+            useBootStateStore.getState().finishBoot();
+            assert.strictEqual(useBootStateStore.getState().phase, 'degraded');
+            assert.strictEqual(useBootStateStore.getState().bootComplete, true);
+        });
+        it('ignores auth status when deriving phase', () => {
+            const { reportFetch } = useBootStateStore.getState();
+            reportFetch('auth', 'fail');
+            reportFetch('workspaces', 'ok', { summary: '3 repos' });
+            reportFetch('sessions', 'ok', { summary: '0 active' });
+            reportFetch('worktrees', 'ok', { summary: '0 trees' });
+            reportFetch('groups', 'ok', { summary: '0 groups' });
+            useBootStateStore.getState().finishBoot();
+            assert.strictEqual(useBootStateStore.getState().phase, 'ready');
+        });
+    });
+    describe('resetBoot', () => {
+        it('resets to greeting phase with fresh lines', () => {
+            useBootStateStore.getState().startBoot();
+            useBootStateStore.getState().reportFetch('auth', 'ok');
+            useBootStateStore.getState().finishBoot();
+            assert.strictEqual(useBootStateStore.getState().phase, 'ready');
+            useBootStateStore.getState().resetBoot();
+            assert.strictEqual(useBootStateStore.getState().phase, 'greeting');
+            assert.strictEqual(useBootStateStore.getState().bootComplete, false);
+            assert.strictEqual(useBootStateStore.getState().lines.length, 5);
+            for (const line of useBootStateStore.getState().lines) {
+                assert.strictEqual(line.status, 'pending');
+            }
+        });
+    });
+});

package/dist/test/stores/sessions-logic.test.js

@@ -0,0 +1,191 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+// Sessions store has complex dependencies (api.js, notifications.js) that
+// don't resolve in the Node test runner. Instead, we test the pure state
+// logic patterns that the Zustand store implements, ensuring parity with
+// the Svelte state module.
+// ── localStorage mock ──────────────────────────────────────────────────────
+const storage = {};
+if (typeof globalThis.localStorage === 'undefined') {
+    Object.defineProperty(globalThis, 'localStorage', {
+        value: {
+            getItem: (key) => storage[key] ?? null,
+            setItem: (key, value) => { storage[key] = value; },
+            removeItem: (key) => { delete storage[key]; },
+            clear: () => { for (const key of Object.keys(storage))
+                delete storage[key]; },
+            get length() { return Object.keys(storage).length; },
+            key: (index) => Object.keys(storage)[index] ?? null,
+        },
+        configurable: true,
+    });
+}
+function getSessionsForRepo(sessions, repoPath) {
+    return sessions.filter((s) => s.repoPath === repoPath);
+}
+function getSessionsForWorkspaceGroup(sessions, workspaceGroups, workspaceId) {
+    const directSessions = sessions.filter((s) => s.workspaceId === workspaceId);
+    const workspace = workspaceGroups.find((w) => w.id === workspaceId);
+    if (!workspace)
+        return directSessions;
+    const repoSet = new Set(workspace.repos);
+    const repoSessions = sessions.filter((s) => !s.workspaceId && repoSet.has(s.repoPath));
+    return [...directSessions, ...repoSessions];
+}
+function rememberSessionForWorkspace(map, workspacePath, sessionId) {
+    return { ...map, [workspacePath]: sessionId };
+}
+function recallSessionForWorkspace(map, sessions, workspacePath) {
+    const id = map[workspacePath];
+    if (!id)
+        return { sessionId: null, updatedMap: map };
+    if (!sessions.some((s) => s.id === id)) {
+        const next = { ...map };
+        delete next[workspacePath];
+        return { sessionId: null, updatedMap: next };
+    }
+    return { sessionId: id, updatedMap: map };
+}
+function setLoading(items, key) {
+    return { ...items, [key]: true };
+}
+function clearLoading(items, key) {
+    const next = { ...items };
+    delete next[key];
+    return next;
+}
+function getNotificationSessionIds(prefs) {
+    return Object.entries(prefs)
+        .filter(([, enabled]) => enabled)
+        .map(([id]) => id);
+}
+function pruneNotifications(prefs, activeIds) {
+    const result = { ...prefs };
+    for (const id of Object.keys(result)) {
+        if (!activeIds.has(id))
+            delete result[id];
+    }
+    return result;
+}
+function pruneWorkspaceSessions(map, activeIds) {
+    const result = { ...map };
+    for (const [path, id] of Object.entries(result)) {
+        if (!activeIds.has(id))
+            delete result[path];
+    }
+    return result;
+}
+// ── Tests ──────────────────────────────────────────────────────────────────
+describe('sessions store pure logic', () => {
+    describe('getSessionsForRepo', () => {
+        const sessions = [
+            { id: 's1', repoPath: '/repo/a' },
+            { id: 's2', repoPath: '/repo/b' },
+            { id: 's3', repoPath: '/repo/a' },
+        ];
+        it('filters sessions by repoPath', () => {
+            const result = getSessionsForRepo(sessions, '/repo/a');
+            assert.strictEqual(result.length, 2);
+            assert.ok(result.every((s) => s.repoPath === '/repo/a'));
+        });
+        it('returns empty for unknown repo', () => {
+            assert.strictEqual(getSessionsForRepo(sessions, '/repo/unknown').length, 0);
+        });
+    });
+    describe('getSessionsForWorkspaceGroup', () => {
+        const sessions = [
+            { id: 's1', repoPath: '/repo/a', workspaceId: 'ws-1' },
+            { id: 's2', repoPath: '/repo/a' },
+            { id: 's3', repoPath: '/repo/b' },
+            { id: 's4', repoPath: '/repo/c', workspaceId: 'ws-2' },
+        ];
+        const groups = [{ id: 'ws-1', repos: ['/repo/a', '/repo/b'] }];
+        it('returns direct sessions + repo sessions for workspace', () => {
+            const result = getSessionsForWorkspaceGroup(sessions, groups, 'ws-1');
+            assert.strictEqual(result.length, 3); // s1 (direct), s2 (repo/a), s3 (repo/b)
+            assert.ok(result.some((s) => s.id === 's1'));
+            assert.ok(result.some((s) => s.id === 's2'));
+            assert.ok(result.some((s) => s.id === 's3'));
+        });
+        it('returns only direct sessions for unknown workspace', () => {
+            const result = getSessionsForWorkspaceGroup(sessions, groups, 'ws-2');
+            assert.strictEqual(result.length, 1);
+            assert.strictEqual(result[0].id, 's4');
+        });
+    });
+    describe('rememberSessionForWorkspace / recallSessionForWorkspace', () => {
+        it('remembers and recalls a session', () => {
+            let map = rememberSessionForWorkspace({}, '/repo/a', 'session-1');
+            const { sessionId } = recallSessionForWorkspace(map, [{ id: 'session-1', repoPath: '/repo/a' }], '/repo/a');
+            assert.strictEqual(sessionId, 'session-1');
+        });
+        it('returns null for unknown workspace', () => {
+            const { sessionId } = recallSessionForWorkspace({}, [], '/repo/unknown');
+            assert.strictEqual(sessionId, null);
+        });
+        it('prunes stale session and returns null', () => {
+            const map = rememberSessionForWorkspace({}, '/repo/a', 'old-session');
+            const { sessionId, updatedMap } = recallSessionForWorkspace(map, [], '/repo/a');
+            assert.strictEqual(sessionId, null);
+            assert.strictEqual(updatedMap['/repo/a'], undefined);
+        });
+        it('overwrites previous session for same workspace', () => {
+            let map = rememberSessionForWorkspace({}, '/repo/a', 'session-1');
+            map = rememberSessionForWorkspace(map, '/repo/a', 'session-2');
+            const { sessionId } = recallSessionForWorkspace(map, [{ id: 'session-2', repoPath: '/repo/a' }], '/repo/a');
+            assert.strictEqual(sessionId, 'session-2');
+        });
+    });
+    describe('setLoading / clearLoading', () => {
+        it('setLoading marks key as loading', () => {
+            const items = setLoading({}, '/repo/a');
+            assert.strictEqual(items['/repo/a'], true);
+        });
+        it('clearLoading removes key', () => {
+            let items = setLoading({}, '/repo/a');
+            items = clearLoading(items, '/repo/a');
+            assert.strictEqual(items['/repo/a'], undefined);
+        });
+        it('clearLoading is a no-op for missing key', () => {
+            const items = clearLoading({}, '/repo/nonexistent');
+            assert.deepStrictEqual(items, {});
+        });
+        it('multiple loading items coexist', () => {
+            let items = setLoading({}, '/repo/a');
+            items = setLoading(items, '/repo/b');
+            assert.strictEqual(items['/repo/a'], true);
+            assert.strictEqual(items['/repo/b'], true);
+            items = clearLoading(items, '/repo/a');
+            assert.strictEqual(items['/repo/a'], undefined);
+            assert.strictEqual(items['/repo/b'], true);
+        });
+    });
+    describe('getNotificationSessionIds', () => {
+        it('returns only enabled session ids', () => {
+            const ids = getNotificationSessionIds({
+                's1': true,
+                's2': false,
+                's3': true,
+            });
+            assert.deepStrictEqual(ids.sort(), ['s1', 's3']);
+        });
+        it('returns empty for no enabled sessions', () => {
+            assert.deepStrictEqual(getNotificationSessionIds({}), []);
+        });
+    });
+    describe('pruneNotifications', () => {
+        it('removes inactive session prefs', () => {
+            const result = pruneNotifications({ 's1': true, 's2': false, 's3': true }, new Set(['s1', 's3']));
+            assert.strictEqual(result['s1'], true);
+            assert.strictEqual(result['s2'], undefined);
+            assert.strictEqual(result['s3'], true);
+        });
+    });
+    describe('pruneWorkspaceSessions', () => {
+        it('removes mappings for inactive sessions', () => {
+            const result = pruneWorkspaceSessions({ '/repo/a': 's1', '/repo/b': 's2' }, new Set(['s1']));
+            assert.strictEqual(result['/repo/a'], 's1');
+            assert.strictEqual(result['/repo/b'], undefined);
+        });
+    });
+});

package/dist/test/stores/toasts-store.test.js

@@ -0,0 +1,66 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { useToastStore } from '../../frontend/src/lib/stores/toasts.js';
+function resetStore() {
+    useToastStore.setState({ toasts: [] });
+}
+describe('toasts Zustand store', () => {
+    beforeEach(() => {
+        resetStore();
+    });
+    describe('showToast', () => {
+        it('adds a toast to the list', () => {
+            useToastStore.getState().showToast('Something went wrong');
+            const { toasts } = useToastStore.getState();
+            assert.strictEqual(toasts.length, 1);
+            assert.strictEqual(toasts[0].message, 'Something went wrong');
+        });
+        it('defaults to error variant', () => {
+            useToastStore.getState().showToast('Error message');
+            assert.strictEqual(useToastStore.getState().toasts[0].variant, 'error');
+        });
+        it('accepts info variant', () => {
+            useToastStore.getState().showToast('Info message', { variant: 'info' });
+            assert.strictEqual(useToastStore.getState().toasts[0].variant, 'info');
+        });
+        it('assigns unique ids to each toast', () => {
+            useToastStore.getState().showToast('First');
+            useToastStore.getState().showToast('Second');
+            const { toasts } = useToastStore.getState();
+            assert.strictEqual(toasts.length, 2);
+            assert.notStrictEqual(toasts[0].id, toasts[1].id);
+        });
+        it('accumulates multiple toasts', () => {
+            useToastStore.getState().showToast('A');
+            useToastStore.getState().showToast('B');
+            useToastStore.getState().showToast('C');
+            assert.strictEqual(useToastStore.getState().toasts.length, 3);
+        });
+    });
+    describe('dismissToast', () => {
+        it('removes a toast by id', () => {
+            useToastStore.getState().showToast('Keep');
+            useToastStore.getState().showToast('Remove');
+            const toasts = useToastStore.getState().toasts;
+            const removeId = toasts[1].id;
+            useToastStore.getState().dismissToast(removeId);
+            const remaining = useToastStore.getState().toasts;
+            assert.strictEqual(remaining.length, 1);
+            assert.strictEqual(remaining[0].message, 'Keep');
+        });
+        it('is a no-op for unknown id', () => {
+            useToastStore.getState().showToast('Only one');
+            useToastStore.getState().dismissToast(99999);
+            assert.strictEqual(useToastStore.getState().toasts.length, 1);
+        });
+        it('can dismiss all toasts one by one', () => {
+            useToastStore.getState().showToast('A');
+            useToastStore.getState().showToast('B');
+            const ids = useToastStore.getState().toasts.map((t) => t.id);
+            for (const id of ids) {
+                useToastStore.getState().dismissToast(id);
+            }
+            assert.strictEqual(useToastStore.getState().toasts.length, 0);
+        });
+    });
+});