zidane-ui 9.0.4 → 9.1.3

package/src/settings/testing/accounts.contract.ts

@@ -1,319 +0,0 @@
-/**
- * What every implementation of the `SettingsHost` `providers` and `mcp`
- * groups does alike, as a vitest suite: the fixture's, the zidane-server
- * one's, the desktop app's (this computer's and a server session's).
- * Exported with `describeSettingsHostContract` from
- * `zidane-ui/settings/testing/contract`.
- *
- * An implementation's test calls {@link describeSettingsAccountsContract}
- * with a harness factory. The contract hands it a backend (the providers
- * and servers it holds, in the kit's shape); the harness builds the host
- * over a backend that holds them and returns a control that reads it back
- * and finishes a sign-in as a browser would. The capabilities list says
- * which groups and actions the host offers: the suite checks the others are
- * undefined and skips their checks.
- */
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { OnboardingSignInState } from 'zidane/chat/pure';
-
-import type { SettingsHost } from '../headless/host';
-import type { SettingsMcpInstance, SettingsMcpServer } from '../headless/mcp';
-import type { SettingsCredential, SettingsProvider } from '../headless/providers';
-import type { SettingsResource } from '../headless/sections-host';
-
-/** A group of `SettingsHost` this suite covers, or one of its optional actions. */
-export type SettingsAccountsCapability =
-  | 'providers'
-  | 'providers.setApiKey'
-  | 'providers.configure'
-  | 'providers.clear'
-  | 'providers.remove'
-  | 'providers.setPreferred'
-  | 'providers.rename'
-  | 'providers.signIn'
-  | 'mcp'
-  | 'mcp.test'
-  | 'mcp.signIn'
-  | 'mcp.signOut'
-  | 'mcp.add'
-  | 'mcp.remove'
-  | 'mcp.instances'
-  | 'mcp.restart';
-
-const PROVIDER_ACTIONS = ['setApiKey', 'configure', 'clear', 'remove', 'setPreferred', 'rename', 'signIn'] as const;
-const MCP_ACTIONS = ['test', 'signIn', 'signOut', 'add', 'remove', 'instances', 'restart'] as const;
-
-/** What the backend behind the host holds. */
-export interface SettingsAccountsBackend {
-  /** The providers and their credentials. */
-  providers: SettingsProvider[];
-  /** The MCP servers of the folder the suite names (`ACCOUNTS_CONTRACT_CWD`). */
-  servers: SettingsMcpServer[];
-  /** The running processes of those servers. */
-  instances: SettingsMcpInstance[];
-}
-
-/** Reads the backend and acts on it from outside. */
-export interface SettingsAccountsControl {
-  /** The stored credentials of a provider now (no `env`). */
-  credentials(provider: string): readonly SettingsCredential[];
-  /** The servers held now, by name. */
-  serverNames(): string[];
-  /** The browser of the sign-in that waits came back: it finishes. */
-  finishSignIn(): void | Promise<void>;
-  /** The servers restarted, in order. Required with `mcp.restart`. */
-  restarts?(): readonly string[];
-}
-
-/** A host built over a backend, its control, and how to tear them down. */
-export interface SettingsAccountsHarness {
-  /** The host under test. */
-  host: SettingsHost;
-  /** Reads and acts on the backend. */
-  control: SettingsAccountsControl;
-  /** Closes listeners after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type SettingsAccountsHarnessFactory = (
-  backend: SettingsAccountsBackend,
-) => SettingsAccountsHarness | Promise<SettingsAccountsHarness>;
-
-/** The folder the suite's MCP calls name. */
-export const ACCOUNTS_CONTRACT_CWD = '/work/app';
-
-const PROVIDERS: SettingsProvider[] = [
-  {
-    key: 'anthropic',
-    label: 'Anthropic',
-    available: true,
-    hasApiKey: true,
-    hasOAuth: true,
-    oauth: true,
-    methods: [
-      { source: 'oauth', key: 'anthropic:oauth:work', label: 'work', detail: 'expires in 12 days', active: true },
-      { source: 'apikey', key: 'anthropic:apikey', detail: 'credentials.json', active: false },
-    ],
-  },
-  {
-    key: 'openai',
-    label: 'OpenAI',
-    available: false,
-    hasApiKey: false,
-    hasOAuth: false,
-    oauth: true,
-    methods: [],
-  },
-];
-const SERVERS: SettingsMcpServer[] = [
-  { name: 'docs', transport: 'stdio', command: 'docs-mcp', authState: 'idle', path: '/h/mcps.json', removable: true },
-  {
-    name: 'linear',
-    transport: 'http',
-    url: 'https://mcp.linear.app/mcp',
-    authState: 'needs-auth',
-    path: '/h/mcps.json',
-    removable: true,
-  },
-];
-
-const INSTANCES: SettingsMcpInstance[] = [
-  { name: 'docs', cwd: ACCOUNTS_CONTRACT_CWD, shared: true, sessions: 2, pid: 4242, retired: false },
-];
-
-const backendOf = (): SettingsAccountsBackend => ({
-  providers: structuredClone(PROVIDERS),
-  servers: structuredClone(SERVERS),
-  instances: structuredClone(INSTANCES),
-});
-
-/** Waits until a resource has read, and returns what it holds. */
-async function settled<T>(resource: SettingsResource<T>): Promise<T | undefined> {
-  const off = resource.subscribe(() => undefined);
-  await resource.refresh();
-  off();
-  return resource.get().data;
-}
-
-/** Waits until a sign-in reaches one of `kinds`. */
-async function reaches(
-  state: { get(): OnboardingSignInState },
-  kinds: readonly OnboardingSignInState['kind'][],
-): Promise<OnboardingSignInState> {
-  await vi.waitFor(() => expect(kinds).toContain(state.get().kind));
-  return state.get();
-}
-
-/**
- * Declares the shared suite of the `providers` and `mcp` groups for one implementation.
- *
- * @param name - The implementation's name, shown in the suite title.
- * @param makeHarness - Builds a fresh host over a backend that holds what it is given, once per test.
- * @param capabilities - The groups and actions the host offers. Every other one must be undefined.
- */
-export function describeSettingsAccountsContract(
-  name: string,
-  makeHarness: SettingsAccountsHarnessFactory,
-  capabilities: readonly SettingsAccountsCapability[],
-): void {
-  const has = (capability: SettingsAccountsCapability) => capabilities.includes(capability);
-
-  describe(`SettingsHost accounts contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const harness = await makeHarness(backendOf());
-      cleanup.push(() => harness.dispose?.());
-      return harness;
-    };
-    const providerOf = async (host: SettingsHost, key: string) =>
-      (await settled(host.providers!.list('')))?.find((p) => p.key === key);
-
-    it('offers exactly its groups and actions; the ones it leaves out are undefined', async () => {
-      const { host } = await setup();
-      expect(host.providers === undefined, 'providers').toBe(!has('providers'));
-      expect(host.mcp === undefined, 'mcp').toBe(!has('mcp'));
-      for (const action of PROVIDER_ACTIONS) {
-        if (!host.providers) break;
-        expect(host.providers[action] === undefined, `providers.${action}`).toBe(!has(`providers.${action}`));
-      }
-      for (const action of MCP_ACTIONS) {
-        if (!host.mcp) break;
-        expect(host.mcp[action] === undefined, `mcp.${action}`).toBe(!has(`mcp.${action}`));
-      }
-    });
-
-    it.skipIf(!has('providers'))('lists the providers with their credentials', async () => {
-      const { host } = await setup();
-      const list = await settled(host.providers!.list(''));
-      expect(list?.map((p) => p.key)).toEqual(['anthropic', 'openai']);
-      const anthropic = list!.find((p) => p.key === 'anthropic')!;
-      expect(anthropic.available).toBe(true);
-      expect(anthropic.methods.find((m) => m.active)?.key).toBe('anthropic:oauth:work');
-      expect(list!.find((p) => p.key === 'openai')!.available).toBe(false);
-    });
-
-    it.skipIf(!has('providers.setApiKey'))('setApiKey stores the key and the list shows it', async () => {
-      const { host, control } = await setup();
-      await host.providers!.setApiKey!('', 'openai', 'sk-test');
-      expect(control.credentials('openai').map((c) => c.source)).toContain('apikey');
-      await vi.waitFor(async () => expect((await providerOf(host, 'openai'))?.hasApiKey).toBe(true));
-    });
-
-    it.skipIf(!has('providers.remove'))('remove drops one stored credential', async () => {
-      const { host, control } = await setup();
-      await host.providers!.remove!('', 'anthropic', 'anthropic:apikey');
-      expect(control.credentials('anthropic').map((c) => c.key)).toEqual(['anthropic:oauth:work']);
-      await vi.waitFor(async () => expect((await providerOf(host, 'anthropic'))?.hasApiKey).toBe(false));
-    });
-
-    it.skipIf(!has('providers.clear'))('clear drops every stored credential', async () => {
-      const { host, control } = await setup();
-      await host.providers!.clear!('', 'anthropic');
-      expect(control.credentials('anthropic')).toEqual([]);
-      await vi.waitFor(async () => expect((await providerOf(host, 'anthropic'))?.available).toBe(false));
-    });
-
-    it.skipIf(!has('providers.setPreferred'))('setPreferred makes a stored credential the one in use', async () => {
-      const { host, control } = await setup();
-      await host.providers!.setPreferred!('', 'anthropic', { key: 'anthropic:apikey' });
-      expect(control.credentials('anthropic').find((c) => c.active)?.key).toBe('anthropic:apikey');
-    });
-
-    it.skipIf(!has('providers.rename'))('rename renames an OAuth account', async () => {
-      const { host, control } = await setup();
-      await host.providers!.rename!('', 'anthropic', 'anthropic:oauth:work', 'office');
-      expect(control.credentials('anthropic').find((c) => c.key === 'anthropic:oauth:work')?.label).toBe('office');
-    });
-
-    it.skipIf(!has('providers.configure'))('configure resolves for a provider', async () => {
-      const { host } = await setup();
-      await expect(host.providers!.configure!('', 'openai', { endpoint: 'https://x' })).resolves.toBeUndefined();
-    });
-
-    it.skipIf(!has('providers.signIn'))(
-      'a sign-in opens its page, finishes, and the list shows the account',
-      async () => {
-        const { host, control } = await setup();
-        const flow = host.providers!.signIn!('openai');
-        const open = await reaches(flow.state, ['url', 'device', 'prompt']);
-        expect(open.kind === 'url' || open.kind === 'device' ? open.url : 'prompt').toBeTruthy();
-        await control.finishSignIn();
-        await reaches(flow.state, ['done']);
-        await vi.waitFor(async () => expect((await providerOf(host, 'openai'))?.available).toBe(true));
-      },
-    );
-
-    it.skipIf(!has('providers.signIn'))('a cancelled sign-in never ends signed in', async () => {
-      const { host } = await setup();
-      const flow = host.providers!.signIn!('openai');
-      flow.cancel();
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      expect(flow.state.get().kind).not.toBe('done');
-    });
-
-    it.skipIf(!has('mcp'))('lists the servers of the folder', async () => {
-      const { host } = await setup();
-      const list = await settled(host.mcp!.servers(ACCOUNTS_CONTRACT_CWD));
-      expect(list?.map((s) => s.name)).toEqual(['docs', 'linear']);
-      expect(list?.find((s) => s.name === 'linear')?.transport).toBe('http');
-    });
-
-    it.skipIf(!has('mcp.test'))('test records how the server answered', async () => {
-      const { host } = await setup();
-      const servers = host.mcp!.servers(ACCOUNTS_CONTRACT_CWD);
-      const off = servers.subscribe(() => undefined);
-      await host.mcp!.test!(ACCOUNTS_CONTRACT_CWD, 'docs');
-      expect(servers.get().data?.find((s) => s.name === 'docs')?.test).toBeDefined();
-      off();
-    });
-
-    it.skipIf(!has('mcp.add'))('add writes a server; a read shows it', async () => {
-      const { host, control } = await setup();
-      await host.mcp!.add!(ACCOUNTS_CONTRACT_CWD, {
-        entry: { name: 'search', transport: 'stdio', command: 'search-mcp' },
-        scope: 'user',
-      });
-      expect(control.serverNames()).toContain('search');
-      expect((await settled(host.mcp!.servers(ACCOUNTS_CONTRACT_CWD)))?.map((s) => s.name)).toContain('search');
-    });
-
-    it.skipIf(!has('mcp.remove'))('remove drops a server; a read shows it gone', async () => {
-      const { host, control } = await setup();
-      await host.mcp!.remove!(ACCOUNTS_CONTRACT_CWD, 'docs');
-      expect(control.serverNames()).not.toContain('docs');
-      expect((await settled(host.mcp!.servers(ACCOUNTS_CONTRACT_CWD)))?.map((s) => s.name)).not.toContain('docs');
-    });
-
-    it.skipIf(!has('mcp.signIn'))('a server sign-in opens its page and finishes', async () => {
-      const { host, control } = await setup();
-      const flow = host.mcp!.signIn!(ACCOUNTS_CONTRACT_CWD, 'linear');
-      await reaches(flow.state, ['url']);
-      await control.finishSignIn();
-      await reaches(flow.state, ['done']);
-    });
-
-    it.skipIf(!has('mcp.instances'))('lists the running processes of the folder', async () => {
-      const { host } = await setup();
-      const list = await settled(host.mcp!.instances!(ACCOUNTS_CONTRACT_CWD));
-      expect(list).toEqual([expect.objectContaining({ name: 'docs', shared: true, sessions: 2, retired: false })]);
-    });
-
-    it.skipIf(!has('mcp.restart'))("restart ends a server's processes", async () => {
-      const { host, control } = await setup();
-      await host.mcp!.restart!(ACCOUNTS_CONTRACT_CWD, 'docs');
-      expect(control.restarts?.()).toEqual(['docs']);
-    });
-
-    it.skipIf(!has('mcp.signOut'))('signOut forgets the sign-in; a read shows it', async () => {
-      const { host } = await setup();
-      await host.mcp!.signOut!(ACCOUNTS_CONTRACT_CWD, 'linear');
-      const list = await settled(host.mcp!.servers(ACCOUNTS_CONTRACT_CWD));
-      expect(list?.find((s) => s.name === 'linear')?.authState).not.toBe('authed');
-    });
-  });
-}

package/src/settings/testing/claude-import.contract.ts

@@ -1,93 +0,0 @@
-/**
- * What every implementation of `SettingsHost.claudeImport` does alike, as a
- * vitest suite. Exported from `zidane-ui/settings/testing/contract`.
- *
- * The contract hands the harness a {@link SettingsClaudeImportBackend}: what
- * `~/.claude` holds and what an import answers. `offered` says whether the
- * host has the group: the suite checks it is undefined otherwise.
- */
-import { afterEach, describe, expect, it } from 'vitest';
-
-import type {
-  SettingsClaudeImportDetect,
-  SettingsClaudeImportSelection,
-  SettingsClaudeImportSummary,
-} from '../headless/claude-import';
-import type { SettingsHost } from '../headless/host';
-
-/** What the backend behind the host holds. */
-export interface SettingsClaudeImportBackend {
-  /** What `~/.claude` holds. */
-  detect: SettingsClaudeImportDetect;
-  /** What an import answers. */
-  summary: SettingsClaudeImportSummary;
-}
-
-/** A host built over a backend, and how to tear it down. */
-export interface SettingsClaudeImportHarness {
-  /** The host under test. */
-  host: SettingsHost;
-  /** The selections the backend imported, in order. */
-  runs?(): SettingsClaudeImportSelection[];
-  /** Closes listeners after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type SettingsClaudeImportHarnessFactory = (
-  backend: SettingsClaudeImportBackend,
-) => SettingsClaudeImportHarness | Promise<SettingsClaudeImportHarness>;
-
-const BACKEND: SettingsClaudeImportBackend = {
-  detect: { available: true, counts: { project: 2, all: 5 } },
-  summary: {
-    sessions: { imported: 2, skipped: 0, empty: 0, failed: [] },
-    mcps: { copied: ['linear'], skipped: [], failed: [] },
-    notes: ['CLAUDE.md is read natively.'],
-  },
-};
-
-/**
- * Declares the shared `SettingsHost.claudeImport` suite for one implementation.
- *
- * @param name - The implementation's name, shown in the suite title.
- * @param makeHarness - Builds a fresh host over a backend that holds what it is given, once per test.
- * @param offered - Whether the host offers `claudeImport`.
- */
-export function describeSettingsClaudeImportContract(
-  name: string,
-  makeHarness: SettingsClaudeImportHarnessFactory,
-  offered: boolean,
-): void {
-  describe(`SettingsHost.claudeImport contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const harness = await makeHarness(structuredClone(BACKEND));
-      cleanup.push(() => harness.dispose?.());
-      return harness;
-    };
-
-    it(offered ? 'offers claudeImport' : 'leaves claudeImport out', async () => {
-      const { host } = await setup();
-      expect(host.claudeImport === undefined).toBe(!offered);
-    });
-
-    it.skipIf(!offered)('detects the setup and counts its transcripts', async () => {
-      const { host } = await setup();
-      expect(await host.claudeImport!.detect('/w')).toEqual({ available: true, counts: { project: 2, all: 5 } });
-    });
-
-    it.skipIf(!offered)('imports the selection and answers what it did', async () => {
-      const harness = await setup();
-      const selection = { sessions: true, mcps: true, skills: false, commands: false, allProjects: false };
-      const summary = await harness.host.claudeImport!.run('/w', selection);
-      expect(summary.sessions?.imported).toBe(2);
-      expect(summary.mcps?.copied).toEqual(['linear']);
-      if (harness.runs) expect(harness.runs()).toEqual([selection]);
-    });
-  });
-}

package/src/settings/testing/contract.ts

@@ -1,192 +0,0 @@
-/**
- * What every `SettingsHost` implementation does alike, as a vitest suite: the in-memory fixture
- * (`createFixtureSettingsHost`), the zidane-server one (`createServerSettingsHost`), the desktop app's.
- *
- * An implementation's test calls {@link describeSettingsHostContract} with a harness factory. The
- * contract hands it a {@link SettingsHostContractBackend}: the settings stored, whether reads fail and
- * whether this connection may write. The harness builds the host over a backend that does that, and
- * returns a {@link SettingsHostContractControl} that reads the backend and changes it from outside.
- * The capabilities list says which optional members the host offers: the suite checks the others are
- * left out (undefined, never a throwing stub) and skips what needs them. `traits` says which failures
- * the backend can stage at all (a desktop store never fails a read).
- *
- *   describeSettingsHostContract('createServerSettingsHost', (backend) => ({ host, control }), [
- *     'update',
- *     'writable',
- *   ]);
- */
-import type { Settings } from 'zidane/chat';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { DEFAULT_SETTINGS } from '../headless/catalog';
-import { isSettingsError, type SettingsDocument, type SettingsHost } from '../headless/host';
-
-// The catalog and diagnostics groups (skills, extensions, plugins, …) have their own suite.
-export * from './sections.contract';
-export * from './accounts.contract';
-export * from './models.contract';
-export * from './extension-options.contract';
-export * from './claude-import.contract';
-export * from './performance.contract';
-
-/** An optional `SettingsHost` member. */
-export type SettingsHostCapability = 'update' | 'writable';
-
-const CAPABILITIES: readonly SettingsHostCapability[] = ['update', 'writable'];
-
-/** What the backend behind the host holds. */
-export interface SettingsHostContractBackend {
-  /** The stored settings (a partial document: the host fills the rest from `DEFAULT_SETTINGS`). */
-  values: Partial<Settings>;
-  /** Reads fail. */
-  unreadable: boolean;
-  /** This connection may write. */
-  writable: boolean;
-}
-
-/** Reads the backend and changes it from outside. */
-export interface SettingsHostContractControl {
-  /** The settings stored now. */
-  stored(): Partial<Settings>;
-  /** Another writer changed the stored settings. The host shows them after its next `refresh` (or sooner). */
-  store(patch: Partial<Settings>): void;
-  /** Refuse the next writes (`traits.refusedWrite`). */
-  refuse?(next: boolean): void;
-}
-
-/** A host built over a backend, the backend's control, and how to tear them down. */
-export interface SettingsHostHarness {
-  /** The host under test. */
-  host: SettingsHost;
-  /** Reads and changes the backend. */
-  control: SettingsHostContractControl;
-  /** Closes listeners after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type SettingsHostHarnessFactory = (
-  backend: SettingsHostContractBackend,
-) => SettingsHostHarness | Promise<SettingsHostHarness>;
-
-/** Failures the backend can stage. Default: both. */
-export interface SettingsHostContractTraits {
-  /** A read can fail (the document lands on an error). */
-  failedRead?: boolean;
-  /** A write can be refused (`control.refuse`). */
-  refusedWrite?: boolean;
-}
-
-const STORED: Partial<Settings> = { showThinking: false, maxTurns: 40, transcriptDensity: 'compact' };
-
-const valuesOf = (doc: SettingsDocument): Settings => {
-  if (doc.status !== 'ready') throw new Error(`document is ${doc.status}`);
-  return doc.values;
-};
-
-/**
- * Declares the shared `SettingsHost` suite for one implementation.
- *
- * @param name - The implementation's name, shown in the suite title.
- * @param makeHarness - Builds a fresh host over a backend that holds what it is given, once per test.
- * @param capabilities - The optional members the host offers. Every other optional member must be undefined.
- * @param traits - The failures the backend can stage.
- */
-export function describeSettingsHostContract(
-  name: string,
-  makeHarness: SettingsHostHarnessFactory,
-  capabilities: readonly SettingsHostCapability[],
-  traits: SettingsHostContractTraits = {},
-): void {
-  const has = (capability: SettingsHostCapability) => capabilities.includes(capability);
-  const { failedRead = true, refusedWrite = true } = traits;
-
-  describe(`SettingsHost contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async (backend: Partial<SettingsHostContractBackend> = {}) => {
-      const harness = await makeHarness({ values: STORED, unreadable: false, writable: true, ...backend });
-      cleanup.push(() => harness.dispose?.());
-      return harness;
-    };
-
-    it('offers exactly its capabilities; the members it leaves out are undefined', async () => {
-      const { host } = await setup();
-      expect(typeof host.document.get).toBe('function');
-      expect(typeof host.refresh).toBe('function');
-      for (const capability of CAPABILITIES) {
-        const member = host[capability];
-        expect(member === undefined, capability).toBe(!has(capability));
-      }
-    });
-
-    it('reads the stored settings over the defaults', async () => {
-      const { host } = await setup();
-      await host.refresh();
-      const values = valuesOf(host.document.get());
-      expect(values.showThinking).toBe(false);
-      expect(values.maxTurns).toBe(40);
-      expect(values.transcriptDensity).toBe('compact');
-      expect(values.autoTitle).toBe(DEFAULT_SETTINGS.autoTitle);
-    });
-
-    it('tells subscribers when a refresh brings an outside change', async () => {
-      const { host, control } = await setup();
-      await host.refresh();
-      const seen: SettingsDocument[] = [];
-      const off = host.document.subscribe(() => seen.push(host.document.get()));
-      control.store({ maxTurns: 7 });
-      await host.refresh();
-      off();
-      expect(valuesOf(host.document.get()).maxTurns).toBe(7);
-      expect(seen.length).toBeGreaterThan(0);
-    });
-
-    it.skipIf(!failedRead)('lands on a typed error when the first read fails, and refresh never rejects', async () => {
-      const { host } = await setup({ unreadable: true });
-      await expect(host.refresh()).resolves.toBeUndefined();
-      const doc = host.document.get();
-      expect(doc.status).toBe('error');
-      if (doc.status === 'error') expect(isSettingsError(doc.error)).toBe(true);
-    });
-
-    it.skipIf(!has('update'))('update shows the patch and the backend stores it', async () => {
-      const { host, control } = await setup();
-      await host.refresh();
-      await host.update!({ maxTurns: 12, showThinking: true });
-      const values = valuesOf(host.document.get());
-      expect(values.maxTurns).toBe(12);
-      expect(values.showThinking).toBe(true);
-      expect(control.stored().maxTurns).toBe(12);
-      expect(control.stored().showThinking).toBe(true);
-    });
-
-    it.skipIf(!has('update') || !refusedWrite)(
-      'a refused update rejects with a typed error and the document goes back to the stored settings',
-      async () => {
-        const { host, control } = await setup();
-        await host.refresh();
-        control.refuse!(true);
-        const error = await host.update!({ maxTurns: 99 }).then(
-          () => null,
-          (e: unknown) => e,
-        );
-        expect(isSettingsError(error)).toBe(true);
-        expect(valuesOf(host.document.get()).maxTurns).toBe(40);
-        expect(control.stored().maxTurns).toBe(40);
-      },
-    );
-
-    it.skipIf(!has('writable'))('writable says whether this connection may write', async () => {
-      const yes = await setup({ writable: true });
-      const no = await setup({ writable: false });
-      await yes.host.refresh();
-      await no.host.refresh();
-      expect(yes.host.writable!.get()).toBe(true);
-      expect(no.host.writable!.get()).toBe(false);
-    });
-  });
-}