@micha.bigler/ui-core-micha 3.14.4 → 4.0.1

package/tests/chatWorkspace.test.jsx

@@ -1,234 +0,0 @@
-// @vitest-environment jsdom
-import React from 'react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
-
-vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key, values) => (values?.model !== undefined ? `${key}:${values.model}` : key) }) }));
-vi.mock('@mui/icons-material', () => ({ MoreVert: () => null }));
-
-import ChatWorkspace from '../src/chat/ChatWorkspace';
-
-class FakeSocket {
-  static OPEN = 1;
-  static instances = [];
-  constructor(url) { this.url = url; this.readyState = 0; this.sent = []; FakeSocket.instances.push(this); }
-  open() { this.readyState = 1; this.onopen?.(); }
-  push(frame) { this.onmessage?.({ data: JSON.stringify(frame) }); }
-  send(data) { this.sent.push(JSON.parse(data)); }
-  close(code = 1000) { this.readyState = 3; this.onclose?.({ code }); }
-}
-
-const catalogue = {
-  entries: [
-    { id: 'cli-sonnet', driver: 'claude_cli', model: 'sonnet', label: 'Sonnet', efforts: ['low', 'high'], billing: 'subscription' },
-    { id: 'oa', driver: 'openai_api', model: 'gpt', label: 'GPT', efforts: ['medium'], billing: 'pay_per_use' },
-  ],
-  default: { entry: 'cli-sonnet', effort: 'high' },
-};
-const baseChat = { id: 7, title: 'Budget', archived_at: null, selection: { entry: 'cli-sonnet', effort: 'high' } };
-
-function makeApi(extra = {}) {
-  return {
-    getStatus: vi.fn().mockResolvedValue({ status: 'available' }),
-    getCatalogue: vi.fn().mockResolvedValue(catalogue),
-    listChats: vi.fn().mockImplementation(async ({ archived } = {}) => ({ results: archived ? [] : [baseChat], next: null })),
-    createChat: vi.fn().mockResolvedValue({ ...baseChat, id: 8, title: '' }),
-    updateChat: vi.fn().mockImplementation(async (id, patch) => ({ ...baseChat, id, ...patch })),
-    deleteChat: vi.fn().mockResolvedValue(null),
-    listTurns: vi.fn().mockResolvedValue({ results: [], next: null }),
-    ...extra,
-  };
-}
-
-async function openChat(api) {
-  render(<ChatWorkspace api={api} wsUrl={(id) => `ws://test/${id}`} />);
-  fireEvent.click(await screen.findByText('Budget'));
-  await waitFor(() => expect(FakeSocket.instances.length).toBe(1));
-  const socket = FakeSocket.instances[0];
-  act(() => socket.open());
-  return socket;
-}
-
-beforeEach(() => { globalThis.WebSocket = FakeSocket; });
-afterEach(() => { cleanup(); delete globalThis.WebSocket; FakeSocket.instances = []; });
-
-describe('ChatWorkspace streaming', () => {
-  it('streams deltas into the answer and replaces them with the final turn and its sources', async () => {
-    const socket = await openChat(makeApi());
-    fireEvent.change(screen.getByRole('textbox', { name: 'Chat.message' }), { target: { value: 'Hello' } });
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.send' }));
-    expect(socket.sent).toEqual([{ type: 'send', message: 'Hello' }]);
-    expect(screen.getByText('Hello')).toBeTruthy();
-    expect(screen.getByRole('button', { name: 'Chat.stop' })).toBeTruthy();
-    expect(screen.getByRole('button', { name: 'Chat.send' }).disabled).toBe(true);
-
-    act(() => socket.push({ type: 'tool', phase: 'start', name: 'kb', label: 'Searching the knowledge base' }));
-    expect(screen.getByText('Searching the knowledge base')).toBeTruthy();
-    act(() => { socket.push({ type: 'delta', text: 'Par' }); socket.push({ type: 'delta', text: 'tial' }); });
-    expect(screen.getByText('Partial')).toBeTruthy();
-
-    act(() => socket.push({ type: 'turn', turn: { id: 40, seq: 1, user_text: 'Hello', assistant_text: 'Final text', state: 'completed', sources: [{ label: 'KB-1', reference: 'kb://1' }], driver: 'claude_cli', model: 'Sonnet', effort: 'high' } }));
-    expect(screen.queryByText('Partial')).toBeNull();
-    expect(screen.getByText('Final text')).toBeTruthy();
-    expect(screen.getByText('KB-1')).toBeTruthy();
-    expect(screen.queryByText('Searching the knowledge base')).toBeNull();
-    expect(screen.getByRole('button', { name: 'Chat.send' })).toBeTruthy();
-  });
-
-  it('sends stop over the socket while a turn runs', async () => {
-    const socket = await openChat(makeApi());
-    fireEvent.change(screen.getByRole('textbox', { name: 'Chat.message' }), { target: { value: 'Hello' } });
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.send' }));
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.stop' }));
-    expect(socket.sent.at(-1)).toEqual({ type: 'stop' });
-  });
-
-  it('does not resend anything after a reconnect', async () => {
-    vi.useFakeTimers({ shouldAdvanceTime: true });
-    try {
-      const socket = await openChat(makeApi());
-      fireEvent.change(screen.getByRole('textbox', { name: 'Chat.message' }), { target: { value: 'Hello' } });
-      fireEvent.click(screen.getByRole('button', { name: 'Chat.send' }));
-      act(() => socket.close(1006));
-      act(() => { vi.advanceTimersByTime(1000); });
-      expect(FakeSocket.instances).toHaveLength(2);
-      act(() => FakeSocket.instances[1].open());
-      expect(FakeSocket.instances[1].sent).toEqual([]);
-    } finally { vi.useRealTimers(); }
-  });
-});
-
-describe('ChatWorkspace edge states', () => {
-  it('shows the usage-limit state with Change model, which opens the picker', async () => {
-    const socket = await openChat(makeApi());
-    fireEvent.change(screen.getByRole('textbox', { name: 'Chat.message' }), { target: { value: 'Hello' } });
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.send' }));
-    act(() => socket.push({ type: 'error', code: 'quota_exceeded' }));
-    expect(screen.getByText('Chat.usageLimit:Sonnet')).toBeTruthy();
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.changeModel' }));
-    expect(screen.getByRole('group', { name: 'Chat.driver.openai_api' })).toBeTruthy();
-  });
-
-  it('shows an interrupted turn from history with Retry, which sends its text again only on click', async () => {
-    const api = makeApi({ listTurns: vi.fn().mockResolvedValue({ results: [{ id: 5, seq: 1, user_text: 'Again please', assistant_text: 'Half', state: 'interrupted', sources: [], driver: 'claude_cli', model: 'Sonnet', effort: 'high' }], next: null }) });
-    const socket = await openChat(api);
-    await screen.findByText('Chat.interrupted');
-    expect(socket.sent).toEqual([]);
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.retry' }));
-    expect(socket.sent).toEqual([{ type: 'send', message: 'Again please' }]);
-  });
-
-  it('shows Reconnecting while the connection is being re-established and blocks Send', async () => {
-    const socket = await openChat(makeApi());
-    act(() => socket.close(1006));
-    expect(screen.getByText('Chat.reconnecting')).toBeTruthy();
-    fireEvent.change(screen.getByRole('textbox', { name: 'Chat.message' }), { target: { value: 'x' } });
-    expect(screen.getByRole('button', { name: 'Chat.send' }).disabled).toBe(true);
-  });
-
-  it.each([[4401, 'Chat.sessionEnded'], [4403, 'Chat.accessLost'], [4429, 'Chat.rateLimited']])('stops reconnecting on close code %s and shows its state', async (code, text) => {
-    const socket = await openChat(makeApi());
-    act(() => socket.close(code));
-    expect(screen.getByText(text)).toBeTruthy();
-    expect(FakeSocket.instances).toHaveLength(1);
-  });
-
-  it('shows the not-configured state and loads no chat list', async () => {
-    const api = makeApi({ getStatus: vi.fn().mockResolvedValue({ status: 'not_configured' }) });
-    render(<ChatWorkspace api={api} />);
-    expect(await screen.findByText('Chat.unavailable')).toBeTruthy();
-    expect(screen.getByText('Chat.noModel')).toBeTruthy();
-    expect(screen.queryByRole('button', { name: 'Chat.newChat' })).toBeNull();
-  });
-
-  it('opens an archived chat read-only: Send is disabled and Restore is offered', async () => {
-    const archivedChat = { ...baseChat, archived_at: '2026-10-01T00:00:00Z' };
-    const api = makeApi({ listChats: vi.fn().mockImplementation(async ({ archived } = {}) => ({ results: archived ? [archivedChat] : [], next: null })) });
-    render(<ChatWorkspace api={api} wsUrl={(id) => `ws://test/${id}`} />);
-    fireEvent.click(await screen.findByRole('button', { name: /Chat.archived/ }));
-    fireEvent.click(screen.getByText('Budget'));
-    expect(await screen.findByText('Chat.archivedReadOnly')).toBeTruthy();
-    expect(screen.getByRole('textbox', { name: 'Chat.message' }).disabled).toBe(true);
-    expect(screen.getByRole('button', { name: 'Chat.send' }).disabled).toBe(true);
-    fireEvent.click(screen.getAllByRole('button', { name: 'Chat.restore' })[0]);
-    await waitFor(() => expect(api.updateChat).toHaveBeenCalledWith(7, { archived: false }));
-  });
-
-  it('shows an empty new chat', async () => {
-    const api = makeApi();
-    render(<ChatWorkspace api={api} wsUrl={(id) => `ws://test/${id}`} />);
-    fireEvent.click((await screen.findAllByRole('button', { name: 'Chat.newChat' }))[0]);
-    expect(await screen.findByText('Chat.emptyTitle')).toBeTruthy();
-    expect(api.createChat).toHaveBeenCalled();
-  });
-});
-
-describe('ChatWorkspace load order', () => {
-  it('shows no Reconnecting chip on the first connect', async () => {
-    render(<ChatWorkspace api={makeApi()} wsUrl={(id) => `ws://test/${id}`} />);
-    fireEvent.click(await screen.findByText('Budget'));
-    await waitFor(() => expect(FakeSocket.instances.length).toBe(1));
-    expect(screen.queryByText('Chat.reconnecting')).toBeNull();
-  });
-
-  it('does not request catalogue or chat lists when no model is configured', async () => {
-    const api = makeApi({ getStatus: vi.fn().mockResolvedValue({ status: 'not_configured' }) });
-    render(<ChatWorkspace api={api} />);
-    await screen.findByText('Chat.unavailable');
-    expect(api.getCatalogue).not.toHaveBeenCalled();
-    expect(api.listChats).not.toHaveBeenCalled();
-  });
-});
-
-describe('ChatWorkspace wiring', () => {
-  it('calls the update endpoint when the picker selection changes', async () => {
-    const api = makeApi();
-    await openChat(api);
-    fireEvent.click(screen.getByRole('button', { name: 'Sonnet · Chat.effort.high' }));
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.effort.low' }));
-    await waitFor(() => expect(api.updateChat).toHaveBeenCalledWith(7, { selection: { entry: 'cli-sonnet', effort: 'low' } }));
-  });
-  it('wires rename, archive and delete of a chat to the endpoints', async () => {
-    const api = makeApi();
-    render(<ChatWorkspace api={api} wsUrl={(id) => `ws://test/${id}`} />);
-    await screen.findByText('Budget');
-    const menu = () => fireEvent.click(screen.getAllByRole('button', { name: 'Chat.actions' })[0]);
-    menu();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'Chat.rename' }));
-    fireEvent.change(screen.getByRole('textbox', { name: 'Chat.renameLabel' }), { target: { value: 'Plan' } });
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.save' }));
-    await waitFor(() => expect(api.updateChat).toHaveBeenCalledWith(7, { title: 'Plan' }));
-    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
-    menu();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'Chat.archive' }));
-    await waitFor(() => expect(api.updateChat).toHaveBeenCalledWith(7, { archived: true }));
-    await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
-    menu();
-    fireEvent.click(screen.getByRole('menuitem', { name: 'Chat.delete' }));
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.delete' }));
-    await waitFor(() => expect(api.deleteChat).toHaveBeenCalledWith(7));
-  });
-
-  it('offers no Retry on an archived chat', async () => {
-    const archivedChat = { ...baseChat, archived_at: '2026-10-01T00:00:00Z' };
-    const api = makeApi({
-      listChats: vi.fn().mockImplementation(async ({ archived } = {}) => ({ results: archived ? [archivedChat] : [], next: null })),
-      listTurns: vi.fn().mockResolvedValue({ results: [{ id: 5, seq: 1, user_text: 'q', assistant_text: 'half', state: 'interrupted', sources: [] }], next: null }),
-    });
-    render(<ChatWorkspace api={api} wsUrl={(id) => `ws://test/${id}`} />);
-    fireEvent.click(await screen.findByRole('button', { name: /Chat.archived/ }));
-    fireEvent.click(screen.getByText('Budget'));
-    await screen.findByText('Chat.interrupted');
-    expect(screen.queryByRole('button', { name: 'Chat.retry' })).toBeNull();
-  });
-
-  it('keeps an interrupted turn visible when Retry is clicked without a connection', async () => {
-    const api = makeApi({ listTurns: vi.fn().mockResolvedValue({ results: [{ id: 5, seq: 1, user_text: 'Again', assistant_text: 'half', state: 'interrupted', sources: [] }], next: null }) });
-    const socket = await openChat(api);
-    await screen.findByText('Chat.interrupted');
-    act(() => socket.close(4403));
-    fireEvent.click(screen.getByRole('button', { name: 'Chat.retry' }));
-    expect(screen.getByText('Again')).toBeTruthy();
-    expect(socket.sent).toEqual([]);
-  });
-});

package/tests/checkKitIntegration.test.jsx

@@ -1,219 +0,0 @@
-// @vitest-environment jsdom
-import React from 'react';
-import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
-import i18next from 'i18next';
-import { I18nextProvider } from 'react-i18next';
-
-import apiClient from '../src/auth/apiClient';
-import { AuthContext } from '../src/auth/AuthContext';
-import { checkKitIntegration } from '../src/testing/checkKitIntegration';
-import { uiCoreTranslations } from '../src/i18n/uiCoreTranslations';
-import { LoginPage } from '../src/pages/LoginPage';
-
-const languages = ['de', 'en', 'fr', 'sw'];
-const authMethods = {
-  password_login: true,
-  password_reset: false,
-  signup: false,
-  signup_modes: [],
-  social_login: false,
-  passkey_login: false,
-};
-
-function resources() {
-  return Object.fromEntries(languages.map((language) => [language, {
-    translation: Object.fromEntries(
-      Object.entries(uiCoreTranslations).map(([key, values]) => [key, values[language]]),
-    ),
-  }]));
-}
-
-function makeWrapper(instance, authMethodsOverride = authMethods) {
-  return function FixtureWrapper({ children }) {
-    return (
-      <I18nextProvider i18n={instance}>
-        <AuthContext.Provider value={{
-          user: null,
-          loading: false,
-          login: vi.fn(),
-          authMethods: authMethodsOverride,
-        }}>
-          {children}
-        </AuthContext.Provider>
-      </I18nextProvider>
-    );
-  };
-}
-
-beforeAll(async () => {
-  globalThis.IS_REACT_ACT_ENVIRONMENT = true;
-  await i18next.init({
-    lng: 'en',
-    fallbackLng: false,
-    supportedLngs: languages,
-    resources: resources(),
-    keySeparator: false,
-    nsSeparator: false,
-    interpolation: { escapeValue: false },
-  });
-});
-
-afterEach(async () => {
-  await i18next.changeLanguage('en');
-  for (const language of languages) {
-    i18next.removeResourceBundle(language, 'translation');
-    i18next.addResourceBundle(language, 'translation', resources()[language].translation, true, true);
-  }
-});
-
-describe('checkKitIntegration', () => {
-  it('passes for a correctly wired app fixture', async () => {
-    const { findings } = await checkKitIntegration({
-      i18n: i18next,
-      wrapper: makeWrapper(i18next),
-      pages: [LoginPage],
-    });
-
-    expect(findings).toEqual([]);
-  });
-
-  it('does not flag a legitimate short lowercase translated word as a raw backend code', async () => {
-    // Auth.LOGIN_OR's German value is literally "oder" -- all-lowercase, no
-    // spaces, length 4 -- the exact shape a naive raw-code heuristic would
-    // false-positive on. Render LoginForm's sign-up/forgot-password divider
-    // (onSignUp truthy) in German to actually exercise that rendered text.
-    await i18next.changeLanguage('de');
-    const { findings } = await checkKitIntegration({
-      i18n: i18next,
-      wrapper: makeWrapper(i18next, { ...authMethods, signup: true, signup_modes: ['self_signup_open'] }),
-      pages: [LoginPage],
-    });
-
-    expect(findings).toEqual([]);
-  });
-
-  it('reports one catalogue finding for one missing language key', async () => {
-    const key = 'Auth.field.email.invalid';
-    const french = { ...resources().fr.translation };
-    delete french[key];
-    i18next.removeResourceBundle('fr', 'translation');
-    i18next.addResourceBundle('fr', 'translation', french, true, true);
-
-    const { findings } = await checkKitIntegration({
-      i18n: i18next,
-      wrapper: makeWrapper(i18next),
-      pages: [],
-    });
-
-    expect(findings).toHaveLength(1);
-    expect(findings[0]).toMatchObject({ check: 'catalogue' });
-    expect(findings[0].reason).toContain(`${key} for language fr`);
-  });
-
-  it('still reports a missing key when the consumer app configures a fallback language', async () => {
-    // A consumer typically sets fallbackLng (e.g. "en"), not "false" like the
-    // fixture above. Without forcing fallbackLng: false per-call, i18next's
-    // exists() would resolve the missing "fr" key through the fallback and
-    // read as present, masking the real gap this check exists to catch.
-    const key = 'Auth.field.email.invalid';
-    const french = { ...resources().fr.translation };
-    delete french[key];
-    i18next.removeResourceBundle('fr', 'translation');
-    i18next.addResourceBundle('fr', 'translation', french, true, true);
-    i18next.options.fallbackLng = 'en';
-
-    try {
-      const { findings } = await checkKitIntegration({
-        i18n: i18next,
-        wrapper: makeWrapper(i18next),
-        pages: [],
-      });
-
-      expect(findings).toHaveLength(1);
-      expect(findings[0]).toMatchObject({ check: 'catalogue' });
-      expect(findings[0].reason).toContain(`${key} for language fr`);
-    } finally {
-      i18next.options.fallbackLng = false;
-    }
-  });
-
-  it('reports when the app passes a separate i18next instance', async () => {
-    const separate = i18next.createInstance();
-    await separate.init({
-      lng: 'en',
-      fallbackLng: false,
-      supportedLngs: languages,
-      resources: resources(),
-      keySeparator: false,
-      nsSeparator: false,
-    });
-
-    const { findings } = await checkKitIntegration({
-      i18n: separate,
-      wrapper: makeWrapper(separate),
-      pages: [],
-    });
-
-    expect(findings.some(({ check }) => check === 'instance')).toBe(true);
-  });
-
-  it('reports a page when the consumer wrapper throws', async () => {
-    function ThrowingWrapper() {
-      throw new Error('provider exploded');
-    }
-
-    const before = apiClient.defaults.adapter;
-    const { findings } = await checkKitIntegration({
-      i18n: i18next,
-      wrapper: ThrowingWrapper,
-      pages: [LoginPage],
-    });
-
-    expect(findings.some(({ check, reason }) => check === 'render' && reason.includes('LoginPage'))).toBe(true);
-    expect(apiClient.defaults.adapter).toBe(before);
-  });
-
-  it('passes the exact invalid-email resolver regression through the real login page', async () => {
-    const { findings } = await checkKitIntegration({
-      i18n: i18next,
-      wrapper: makeWrapper(i18next),
-      pages: [],
-    });
-
-    expect(findings).toEqual([]);
-  });
-
-  it('restores the transport adapter after a successful check', async () => {
-    const before = apiClient.defaults.adapter;
-    await checkKitIntegration({
-      i18n: i18next,
-      wrapper: makeWrapper(i18next),
-      pages: [],
-    });
-    expect(apiClient.defaults.adapter).toBe(before);
-  });
-
-  it('no longer intercepts a real request once the check has finished', async () => {
-    // Proves the restore is functional, not just reference-equal: a request
-    // made AFTER the check completes must reach the app's own adapter, not
-    // the check's stub (which would reject it as "blocked" or fake a login
-    // failure for the allauth login path).
-    const sentinel = vi.fn().mockResolvedValue({ data: 'real-response', status: 200, headers: {}, config: {} });
-    const before = apiClient.defaults.adapter;
-    apiClient.defaults.adapter = sentinel;
-
-    try {
-      await checkKitIntegration({
-        i18n: i18next,
-        wrapper: makeWrapper(i18next),
-        pages: [],
-      });
-
-      const response = await apiClient.get('/api/some/path');
-      expect(sentinel).toHaveBeenCalled();
-      expect(response.data).toBe('real-response');
-    } finally {
-      apiClient.defaults.adapter = before;
-    }
-  });
-});

package/tests/createAppTheme.test.js

@@ -1,132 +0,0 @@
-import { createTheme } from '@mui/material/styles';
-import { describe, expect, it } from 'vitest';
-
-import { assertThemeComplete, createAppTheme } from '../src/theme';
-import { BASELINE_STATIC } from '../src/theme/tokens';
-
-describe('createAppTheme', () => {
-  it('builds a complete baseline from only an app primary colour', () => {
-    const theme = createAppTheme({ palette: { primary: { main: '#0F62FE' } } });
-
-    expect(assertThemeComplete(theme).findings).toEqual([]);
-    expect(theme.palette.background.subtle).toBe('#F4F5F6');
-    expect(theme.typography.body1.fontSize).toBe('14px');
-    expect(theme.shape.borderRadius).toBe(3);
-    expect(theme.components.MuiPaper.defaultProps).toMatchObject({ elevation: 0, variant: 'outlined' });
-    expect(theme.components.MuiBottomNavigationAction.styleOverrides.label).toMatchObject({
-      fontSize: '12px',
-      fontWeight: 500,
-      lineHeight: 1.2,
-      maxWidth: '100%',
-      whiteSpace: 'nowrap',
-      overflow: 'hidden',
-      textOverflow: 'ellipsis',
-      '&.Mui-selected': { fontSize: '12px' },
-    });
-    expect(theme.components.MuiBottomNavigationAction.styleOverrides.root).toMatchObject({
-      padding: '0 2px',
-      gap: '2px',
-      '& .MuiSvgIcon-root': { width: '22px', height: '22px' },
-    });
-    expect(theme.components.MuiBottomNavigation.styleOverrides.root).not.toHaveProperty('borderTop');
-    expect(theme.components.MuiBottomNavigation.styleOverrides.root).not.toHaveProperty('borderColor');
-    expect(theme.components.MuiBottomNavigationAction.styleOverrides.root)
-      .not.toHaveProperty('minWidth');
-    expect(theme.components.MuiBottomNavigationAction.styleOverrides.root)
-      .not.toHaveProperty('maxWidth');
-    expect(theme.palette.dataSeries.categorical).toHaveLength(6);
-    expect(theme.palette.primary.light).not.toBe(createTheme().palette.primary.light);
-    // MUI's createTheme(options, ...args) only augments the FIRST argument's
-    // palette; every later arg is deep-merged raw, so a status entry missing
-    // `main`/`contrastText` silently keeps MUI's stock hue for color="success"
-    // etc. -- main/contrastText must be explicitly set and clear AA as a
-    // foreground (THEME-2: `warning` deliberately breaks the main===fill
-    // pattern success/error/info follow -- amber cannot serve both a legible
-    // fill AND a legible foreground with one hex, so `warning.main` is the
-    // darker `text` tone instead, `warning.fill` stays the lighter amber for
-    // deliberate fill use).
-    for (const status of ['success', 'error', 'info']) {
-      expect(theme.palette[status].main).toBe(theme.palette[status].fill);
-      expect(theme.palette[status].contrastText).toBe(theme.palette[status].fillText);
-    }
-    expect(theme.palette.warning.main).toBe(theme.palette.warning.text);
-    expect(theme.palette.warning.contrastText).toBe('#FFFFFF');
-  });
-
-  it('throws when palette.primary is missing', () => {
-    expect(() => createAppTheme()).toThrow(/palette\.primary.*required/i);
-  });
-
-  it('throws on a function in an app styleOverrides slot', () => {
-    expect(() => createAppTheme({
-      palette: { primary: { main: '#0F62FE' } },
-      components: { MuiButton: { styleOverrides: { root: () => ({ color: 'red' }) } } },
-    })).toThrow(/components\.MuiButton\.styleOverrides\.root.*object.*variants/i);
-  });
-
-  it('computes component values from the final app status palette', () => {
-    const theme = createAppTheme({
-      palette: {
-        primary: { main: '#0F62FE' },
-        success: { main: '#14532D', text: '#14532D', bg: '#DCFCE7' },
-      },
-    });
-
-    expect(theme.components.MuiAlert.styleOverrides.standardSuccess).toEqual({
-      color: '#14532D',
-      backgroundColor: '#DCFCE7',
-      '& .MuiAlert-icon': { color: '#14532D' },
-    });
-  });
-
-  it('deep-merges app object overrides without dropping baseline properties', () => {
-    const theme = createAppTheme({
-      palette: { primary: { main: '#0F62FE' } },
-      typography: { fontFamily: "'App Sans', sans-serif" },
-      components: { MuiButton: { styleOverrides: { root: { fontSize: '15px' } } } },
-    });
-
-    expect(theme.components.MuiButton.styleOverrides.root).toMatchObject({
-      minHeight: 40,
-      borderRadius: 3,
-      fontSize: '15px',
-    });
-    expect(theme.typography.body1.fontFamily).toBe("'App Sans', sans-serif");
-    expect(theme.components.MuiOutlinedInput.styleOverrides.root.height).toBeUndefined();
-    // variants is a sibling of styleOverrides (MUI matches it independently by
-    // props), not nested inside it -- see src/theme/tokens.js for why.
-    expect(theme.components.MuiOutlinedInput.variants).toContainEqual({
-      props: { multiline: false },
-      style: { height: 40 },
-    });
-  });
-
-  it('returns independent themes for runtime palettes in one process', () => {
-    const blue = createAppTheme({ palette: { primary: { main: '#0F62FE' } } });
-    const purple = createAppTheme({ palette: { primary: { main: '#432CA1' } } });
-
-    expect(blue).not.toBe(purple);
-    expect(blue.palette).not.toBe(purple.palette);
-    expect(blue.palette.dataSeries.categorical).not.toBe(purple.palette.dataSeries.categorical);
-    expect(blue.palette.primary.main).toBe('#0F62FE');
-    expect(purple.palette.primary.main).toBe('#432CA1');
-    expect(blue.palette.controlBorder.focus).not.toBe(purple.palette.controlBorder.focus);
-  });
-
-  it('contains no function anywhere in the baseline components tree', () => {
-    const functionPaths = [];
-    const visit = (value, path) => {
-      if (typeof value === 'function') functionPaths.push(path);
-      else if (value && typeof value === 'object') {
-        Object.entries(value).forEach(([key, child]) => visit(child, `${path}.${key}`));
-      }
-    };
-
-    visit(BASELINE_STATIC.components, 'baseline.components');
-    visit(
-      createAppTheme({ palette: { primary: { main: '#0F62FE' } } }).components,
-      'theme.components',
-    );
-    expect(functionPaths).toEqual([]);
-  });
-});