zidane-ui 9.0.4 → 9.1.3

package/src/chat/testing/fixture-composer-chrome.ts

@@ -1,178 +0,0 @@
-/**
- * The chrome members of the fixture `ComposerHost`: the pickers' writes kept
- * per session, demo models and agent profiles, remembered picks in memory,
- * per-session meters, a run meter played with `runSignal`, and the
- * extensions' strip played with `pushHud`.
- */
-import type {
-  ComposerAgentProfile,
-  ComposerCacheImpact,
-  ComposerContextBreakdown,
-  ComposerContextStatus,
-  ComposerCostStatus,
-  ComposerHudSnapshot,
-  ComposerPrefsState,
-  ComposerRunProgress,
-  ResourceSnapshot,
-} from '../headless/composer/host-chrome';
-import type { ComposerHost } from '../headless/composer/host';
-import { createModelPickerPrefs } from '../headless/composer/model-picker-prefs';
-import type { ComposerModelEntry, ImageModelRow, ModelPickRef } from '../headless/composer/models';
-import { createRunMeter, type RunMeterSignal } from '../headless/composer/run-meter';
-import { constant, type Readable } from '../headless/store';
-
-/** A session's picks as the fixture holds them. */
-export interface FixtureComposerSession {
-  /** The model chain, primary first. */
-  model?: ModelPickRef[];
-  /** The reasoning effort. */
-  effort?: string;
-  /** The enabled options. */
-  options?: Record<string, boolean>;
-  /** The agent profile. */
-  agent?: string;
-}
-
-/** What the fixture's chrome holds. */
-export interface FixtureComposerChromeOptions {
-  /** Each session's picks (the controls write here). */
-  sessions?: Record<string, FixtureComposerSession>;
-  /** The chat models. Default: {@link DEMO_COMPOSER_MODELS}. */
-  models?: readonly ComposerModelEntry[];
-  /** The image models. */
-  imageModels?: readonly ImageModelRow[];
-  /** The agent profiles. Default: {@link DEMO_AGENT_PROFILES}. */
-  agents?: readonly ComposerAgentProfile[];
-  /** The remembered picks. */
-  prefs?: ComposerPrefsState;
-  /** What any switch costs the cache (`null`: unknown). */
-  cacheImpact?: ComposerCacheImpact | null;
-  /** Each session's meters. */
-  context?: Record<
-    string,
-    { status?: ComposerContextStatus; breakdown?: ComposerContextBreakdown; cost?: ComposerCostStatus }
-  >;
-  /** Each session's run in progress. */
-  runProgress?: Record<string, ComposerRunProgress>;
-  /** What extensions show, per session. */
-  hud?: ComposerHudSnapshot;
-}
-
-/** The chrome members, with the controls a demo or a test plays. */
-export interface FixtureComposerChrome extends Required<
-  Pick<ComposerHost, 'controls' | 'models' | 'agents' | 'prefs' | 'pickerPrefs' | 'context' | 'runs' | 'hud'>
-> {
-  /** The backend streams a run signal (`run:start`, `stream:progress`, `turn:end`, `run:end`). */
-  runSignal(signal: RunMeterSignal): void;
-  /** The backend pushes a new extensions snapshot. */
-  pushHud(snapshot: ComposerHudSnapshot): void;
-}
-
-/** Demo chat models for the pickers. */
-export const DEMO_COMPOSER_MODELS: readonly ComposerModelEntry[] = [
-  {
-    providerKey: 'anthropic',
-    providerLabel: 'Anthropic',
-    modelId: 'claude-opus-4-5',
-    modelName: 'Claude Opus 4.5',
-    contextWindow: 200_000,
-    supportsReasoning: true,
-    options: [{ id: 'fast', label: 'Fast mode', description: 'Faster output at a higher price' }],
-  },
-  {
-    providerKey: 'anthropic',
-    providerLabel: 'Anthropic',
-    modelId: 'claude-sonnet-4-5',
-    modelName: 'Claude Sonnet 4.5',
-    contextWindow: 200_000,
-    supportsReasoning: true,
-  },
-  {
-    providerKey: 'openai',
-    providerLabel: 'OpenAI',
-    modelId: 'gpt-5.1',
-    modelName: 'GPT-5.1',
-    contextWindow: 400_000,
-    supportsReasoning: true,
-  },
-];
-
-/** Demo agent profiles. */
-export const DEMO_AGENT_PROFILES: readonly ComposerAgentProfile[] = [
-  { id: 'build', label: 'Build', description: 'Reads, edits and runs', accent: 'accent' },
-  { id: 'plan', label: 'Plan', description: 'Reads and plans, no edits', accent: 'warn' },
-];
-
-const loaded = <T>(data: T): Readable<ResourceSnapshot<T>> =>
-  constant({ data, error: undefined, status: 'success', stale: false, refresh: () => Promise.resolve() });
-const empty = <T>(): Readable<ResourceSnapshot<T | null>> => loaded<T | null>(null);
-
-/**
- * Creates the fixture's chrome members.
- *
- * @param options - What they hold. Leave a list out for the demo one.
- */
-export function createFixtureComposerChrome(options: FixtureComposerChromeOptions = {}): FixtureComposerChrome {
-  const sessions = options.sessions ?? {};
-  const models = loaded(options.models ?? DEMO_COMPOSER_MODELS);
-  const images = loaded(options.imageModels ?? []);
-  const agents = options.agents ?? DEMO_AGENT_PROFILES;
-  let prefs: ComposerPrefsState = { ...options.prefs };
-  const context = options.context ?? {};
-  const meter = createRunMeter();
-  const hudListeners = new Set<(snapshot: ComposerHudSnapshot) => void>();
-  let hud = options.hud ?? { sessions: {}, badges: {} };
-  const write = (sessionId: string, patch: FixtureComposerSession) => {
-    sessions[sessionId] = { ...sessions[sessionId], ...patch };
-  };
-
-  return {
-    controls: {
-      setModel: async (sessionId, primary, fallbacks) => write(sessionId, { model: [primary, ...fallbacks] }),
-      setEffort: async (sessionId, effort) => write(sessionId, { effort }),
-      setModelOptions: async (sessionId, next) => write(sessionId, { options: next }),
-      setAgent: async (sessionId, agent) => write(sessionId, { agent }),
-      cacheImpact: async () => options.cacheImpact ?? null,
-    },
-    models: {
-      catalog: () => models,
-      images: () => images,
-      providers: () => loaded([]),
-    },
-    agents: {
-      list: async () => agents,
-      onChanged: () => () => undefined,
-    },
-    prefs: {
-      get: async () => prefs,
-      set: async (patch) => {
-        prefs = { ...prefs, ...patch };
-      },
-    },
-    pickerPrefs: createModelPickerPrefs({ getItem: () => null, setItem: () => undefined }),
-    context: {
-      status: (sessionId) => (context[sessionId]?.status ? loaded(context[sessionId].status) : empty()),
-      breakdown: (sessionId) => (context[sessionId]?.breakdown ? loaded(context[sessionId].breakdown) : empty()),
-      cost: async (sessionId) => context[sessionId]?.cost ?? null,
-    },
-    runs: {
-      meter: meter.session,
-      progress: async (sessionId) => options.runProgress?.[sessionId] ?? null,
-      noteSeen: meter.noteSeen,
-      noteProgress: meter.noteProgress,
-      settleCost: meter.settleCost,
-    },
-    hud: {
-      get: async () => hud,
-      onState: (listener) => {
-        hudListeners.add(listener);
-        return () => void hudListeners.delete(listener);
-      },
-    },
-    runSignal: (signal) => meter.handle(signal),
-    pushHud(snapshot) {
-      hud = snapshot;
-      for (const listener of hudListeners) listener(snapshot);
-    },
-  };
-}

package/src/chat/testing/fixture-composer-host.ts

@@ -1,147 +0,0 @@
-/**
- * An in-memory `ComposerHost` for docs, demos and tests: drafts kept in a
- * map (`announceDraft` plays another window's edit), demo files, commands,
- * skills and chats for the completions, a ghost-text table, next-prompt
- * suggestions played with `suggest`, and the chrome's members
- * (`fixture-composer-chrome.ts`: pickers, meters, the run meter, the strip).
- */
-import type { ChatReferenceEntry } from 'zidane/chat/pure';
-
-import type {
-  CommandArgSuggestionSummary,
-  CommandSummary,
-  ComposerDraftAttachmentsListener,
-  ComposerHost,
-  ComposerPromptSuggestion,
-  ComposerSharedGhost,
-  FileEntry,
-  PromptAttachment,
-  SharedDraft,
-  SharedDraftChange,
-  SkillConfig,
-} from '../headless/composer/host';
-import {
-  createFixtureComposerChrome,
-  type FixtureComposerChrome,
-  type FixtureComposerChromeOptions,
-} from './fixture-composer-chrome';
-
-/** What {@link createFixtureComposerHost} holds. */
-export interface FixtureComposerHostOptions extends FixtureComposerChromeOptions {
-  /** The shared drafts per session. */
-  drafts?: Record<string, SharedDraft>;
-  /** The files under each root. */
-  files?: Record<string, readonly FileEntry[]>;
-  /** The `/` commands. */
-  commands?: readonly CommandSummary[];
-  /** The argument suggestions per command name. */
-  commandArgs?: Record<string, readonly CommandArgSuggestionSummary[]>;
-  /** The sessions `#` can reference. */
-  chats?: readonly ChatReferenceEntry[];
-  /** The enabled skills. */
-  skills?: readonly SkillConfig[];
-  /** Ghost text completions per draft text. */
-  ghosts?: Record<string, readonly string[]>;
-}
-
-/** The fixture host, with the controls a demo or a test plays. */
-export interface FixtureComposerHost extends Omit<ComposerHost, keyof FixtureComposerChrome>, FixtureComposerChrome {
-  /** Another window changed a session's draft. */
-  announceDraft(sessionId: string, text: string, shell?: boolean): void;
-  /** Another window changed a session's staged files. */
-  announceDraftAttachments(sessionId: string, attachments: PromptAttachment[]): void;
-  /** Another window resolved a ghost text. */
-  announceGhost(ghost: ComposerSharedGhost): void;
-  /** A run ended with a next-prompt suggestion. */
-  suggest(suggestion: ComposerPromptSuggestion): void;
-  /** A run started: the session's suggestion goes stale. */
-  startRun(sessionId: string): void;
-}
-
-/** Demo files for the `@` popover. */
-export const DEMO_COMPOSER_FILES: readonly FileEntry[] = [
-  { path: 'src/index.ts' } as FileEntry,
-  { path: 'src/composer.tsx' } as FileEntry,
-  { path: 'README.md' } as FileEntry,
-];
-
-/** Demo commands for the `/` popover. */
-export const DEMO_COMPOSER_COMMANDS: readonly CommandSummary[] = [
-  { name: 'review', description: 'Review the working tree', group: 'zidane', hasArgCompletion: true },
-  { name: 'compact', description: 'Summarize the conversation so far', group: 'zidane' },
-];
-
-/**
- * Creates a {@link FixtureComposerHost}.
- *
- * @param options - What it holds. Leave a list out for the demo one.
- */
-export function createFixtureComposerHost(options: FixtureComposerHostOptions = {}): FixtureComposerHost {
-  const drafts: Record<string, SharedDraft> = { ...options.drafts };
-  const files = options.files ?? { '': DEMO_COMPOSER_FILES };
-  const commands = options.commands ?? DEMO_COMPOSER_COMMANDS;
-  const commandArgs = options.commandArgs ?? { review: [{ value: 'src' }, { value: 'tests' }] };
-  const chats = options.chats ?? [];
-  const skills = options.skills ?? [];
-  const ghosts = options.ghosts ?? {};
-  const textListeners = new Set<(change: SharedDraftChange) => void>();
-  const fileListeners = new Set<ComposerDraftAttachmentsListener>();
-  const ghostListeners = new Set<(ghost: ComposerSharedGhost) => void>();
-  const readyListeners = new Set<(suggestion: ComposerPromptSuggestion) => void>();
-  const staleListeners = new Set<(sessionId: string) => void>();
-  const add = <T>(set: Set<T>, listener: T) => {
-    set.add(listener);
-    return () => void set.delete(listener);
-  };
-
-  return {
-    ...createFixtureComposerChrome(options),
-    drafts: {
-      get: async (sessionId) => ({ ...(drafts[sessionId] ?? { text: '' }) }),
-      set: async (sessionId, text, shell) => {
-        drafts[sessionId] = { ...drafts[sessionId], text, ...(shell !== undefined ? { shell } : {}) };
-      },
-      setAttachments: async (sessionId, attachments) => {
-        drafts[sessionId] = { ...(drafts[sessionId] ?? { text: '' }), attachments };
-      },
-      onChanged: (listener) => add(textListeners, listener),
-      onAttachmentsChanged: (listener) => add(fileListeners, listener),
-    },
-    completions: {
-      files: async (root) => files[root] ?? files[''] ?? [],
-      commands: async () => commands,
-      commandArgs: async (_scope, name, prefix) =>
-        (commandArgs[name] ?? []).filter((arg) => arg.value.startsWith(prefix)),
-      chats: async () => chats,
-      watchSkills: (_scope, listener) => {
-        listener(skills);
-        return () => undefined;
-      },
-    },
-    autocomplete: {
-      inline: async (_cwd, text) => (ghosts[text] ? [...ghosts[text]] : null),
-      onShared: (listener) => add(ghostListeners, listener),
-    },
-    suggestions: {
-      onReady: (listener) => add(readyListeners, listener),
-      onStale: (listener) => add(staleListeners, listener),
-    },
-    announceDraft(sessionId, text, shell) {
-      drafts[sessionId] = { ...drafts[sessionId], text, ...(shell !== undefined ? { shell } : {}) };
-      for (const listener of textListeners) listener({ sessionId, text, ...(shell !== undefined ? { shell } : {}) });
-    },
-    announceDraftAttachments(sessionId, attachments) {
-      drafts[sessionId] = { ...(drafts[sessionId] ?? { text: '' }), attachments };
-      for (const listener of fileListeners) listener({ sessionId, attachments });
-    },
-    announceGhost(ghost) {
-      for (const listener of ghostListeners) listener(ghost);
-    },
-    suggest(suggestion) {
-      for (const listener of readyListeners) listener(suggestion);
-    },
-    startRun(sessionId) {
-      for (const listener of staleListeners) listener(sessionId);
-    },
-  };
-}

package/src/chat/testing/fixture-sidebar-host.ts

@@ -1,99 +0,0 @@
-/**
- * An in-memory `SidebarHost` for docs, demos and tests: each session's
- * environment commands and what running one answers, with every reveal,
- * window, retry, run and opened host settings recorded for the caller to read.
- */
-import type { EnvironmentActionResult, EnvironmentActionSummary } from 'zidane/chat';
-
-import type { SessionWindowMode, SidebarHost } from '../headless/sidebar/host';
-
-/** One session's environment, as the fixture holds it. */
-export interface FixtureSidebarEnvironment {
-  /** The commands it offers. */
-  actions: readonly EnvironmentActionSummary[];
-  /** What running each one answers (by action id). An action without one answers its label. */
-  results?: Readonly<Record<string, EnvironmentActionResult>>;
-}
-
-/** What {@link createFixtureSidebarHost} holds. */
-export interface FixtureSidebarHostOptions {
-  /** Each session's environment commands. Default: none, and no `environment` member. */
-  environments?: Readonly<Record<string, FixtureSidebarEnvironment>>;
-  /** Offer `revealPath`. Default: true. */
-  reveal?: boolean;
-  /** Offer `openWindow`. Default: true. */
-  windows?: boolean;
-  /** Offer `openHostSettings`. Default: true. */
-  hostSettings?: boolean;
-}
-
-/** What the fixture recorded. */
-export interface FixtureSidebarCalls {
-  /** Every folder revealed, in order. */
-  revealed: string[];
-  /** Every window opened, in order. */
-  windows: { sessionId: string; mode: SessionWindowMode }[];
-  /** Every environment retried, in order. */
-  retried: string[];
-  /** Every environment command run, in order. */
-  ran: { sessionId: string; actionId: string }[];
-  /** Every host whose settings were opened, in order. */
-  hostSettings: string[];
-}
-
-/** The {@link SidebarHost} {@link createFixtureSidebarHost} returns, with what it recorded. */
-export interface FixtureSidebarHost extends SidebarHost {
-  /** What the host was asked to do. */
-  calls: FixtureSidebarCalls;
-}
-
-/**
- * Creates a {@link SidebarHost} held in memory.
- *
- * @param options - The environments, and which members to offer.
- */
-export function createFixtureSidebarHost(options: FixtureSidebarHostOptions = {}): FixtureSidebarHost {
-  const { environments, reveal = true, windows = true, hostSettings = true } = options;
-  const calls: FixtureSidebarCalls = { revealed: [], windows: [], retried: [], ran: [], hostSettings: [] };
-  const environmentOf = (sessionId: string) => environments?.[sessionId];
-  return {
-    calls,
-    ...(reveal
-      ? {
-          revealPath: async (path: string) => {
-            calls.revealed.push(path);
-          },
-        }
-      : {}),
-    ...(windows
-      ? {
-          openWindow: async (sessionId: string, mode: SessionWindowMode) => {
-            calls.windows.push({ sessionId, mode });
-          },
-        }
-      : {}),
-    ...(hostSettings
-      ? {
-          openHostSettings: async (hostId: string) => {
-            calls.hostSettings.push(hostId);
-          },
-        }
-      : {}),
-    ...(environments
-      ? {
-          environment: {
-            actions: async (sessionId: string) => environmentOf(sessionId)?.actions ?? [],
-            run: async (sessionId: string, actionId: string) => {
-              const action = environmentOf(sessionId)?.actions.find((a) => a.id === actionId);
-              if (!action) throw new Error(`No action ${actionId} in ${sessionId}`);
-              calls.ran.push({ sessionId, actionId });
-              return environmentOf(sessionId)?.results?.[actionId] ?? { message: action.label };
-            },
-            retry: async (sessionId: string) => {
-              calls.retried.push(sessionId);
-            },
-          },
-        }
-      : {}),
-  };
-}

package/src/chat/testing/index.ts

@@ -1,12 +0,0 @@
-/**
- * `zidane-ui/chat/testing`: a `ChatHost` that runs in memory
- * (`createFixtureHost`) and demo transcripts, for docs, demos, galleries and
- * an app's own tests. Not for production hosts.
- */
-export * from '../headless/fixture-host';
-export * from './fixture-composer-host';
-export * from './fixture-composer-chrome';
-export * from './fixture-sidebar-host';
-export type { ChatTranscriptFixture } from '../headless/fixture-transcript';
-export { DEMO_TRANSCRIPT } from '../headless/fixtures/demo-transcript';
-export { DEMO_TRANSCRIPT_ALL_KINDS } from '../headless/fixtures/demo-transcript-all-kinds';

package/src/chat/testing/sidebar.contract.ts

@@ -1,196 +0,0 @@
-/**
- * What every `SidebarHost` implementation does alike, as a vitest suite: the in-memory fixture
- * (`createFixtureSidebarHost`), zidane-server (`createServerSidebarHost`), the desktop app's IPC host.
- *
- * An implementation's test calls {@link describeSidebarHostContract} with a harness factory. The
- * contract hands it a {@link SidebarHostContractBackend}: each session's environment commands and what
- * running one answers, and each session's badges. The harness builds the host over a backend that holds them and returns a
- * {@link SidebarHostContractControl} that reads what the backend was asked to do. 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.
- *
- *   describeSidebarHostContract('createServerSidebarHost', (backend) => ({ host, control }), ['environment']);
- */
-import type { EnvironmentActionResult, EnvironmentActionSummary } from 'zidane/chat';
-import type { SessionBadgeEntry } from 'zidane/chat/pure';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import type { SessionWindowMode, SidebarHost } from '../headless/sidebar/host';
-
-/** An optional `SidebarHost` member. */
-export type SidebarHostCapability = 'revealPath' | 'openWindow' | 'environment' | 'badges' | 'openHostSettings';
-
-const CAPABILITIES: readonly SidebarHostCapability[] = [
-  'revealPath',
-  'openWindow',
-  'environment',
-  'badges',
-  'openHostSettings',
-];
-
-/** What the backend behind the host holds. */
-export interface SidebarHostContractBackend {
-  /** Each session's environment: the commands it offers and what running each answers. */
-  environments: Readonly<
-    Record<
-      string,
-      { actions: readonly EnvironmentActionSummary[]; results: Readonly<Record<string, EnvironmentActionResult>> }
-    >
-  >;
-  /** Each session's badges; a session left out has none. */
-  badges: Readonly<Record<string, readonly SessionBadgeEntry[]>>;
-}
-
-/** Reads what the backend was asked to do. */
-export interface SidebarHostContractControl {
-  /** The folders revealed, in order. Only read with `revealPath`. */
-  revealed?(): readonly string[];
-  /** The windows opened, in order. Only read with `openWindow`. */
-  windows?(): readonly { sessionId: string; mode: SessionWindowMode }[];
-  /** The environments set up again, in order. Only read with `environment`. */
-  retried?(): readonly string[];
-  /** The hosts whose settings were opened, in order. Only read with `openHostSettings`. */
-  hostSettingsOpened?(): readonly string[];
-  /** The backend records or changes an artifact of `sessionId`. Only called with `badges`. */
-  changeArtifacts?(sessionId: string): void;
-  /** The backend's badge kinds change (extensions installed or removed). Only called with `badges`. */
-  changeKinds?(): void;
-}
-
-/** A host built over a backend, the backend's control, and how to tear them down. */
-export interface SidebarHostHarness {
-  /** The host under test. */
-  host: SidebarHost;
-  /** Reads the backend. */
-  control: SidebarHostContractControl;
-  /** Closes connections after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type SidebarHostHarnessFactory = (
-  backend: SidebarHostContractBackend,
-) => SidebarHostHarness | Promise<SidebarHostHarness>;
-
-const BACKEND: SidebarHostContractBackend = {
-  environments: {
-    s1: {
-      actions: [
-        { id: 'push', label: 'Push branch' },
-        { id: 'pr', label: 'Open pull request', description: 'On GitHub' },
-      ],
-      results: {
-        push: { message: 'Pushed zidane/ab12 to origin.' },
-        pr: { message: 'Opened #12.', url: 'https://github.com/o/r/pull/12' },
-      },
-    },
-  },
-  badges: {
-    s1: [{ kind: 'commit', artifactCount: 2, badge: { text: '2 commits', count: 2, order: 10 } }],
-  },
-};
-
-/**
- * Declares the shared `SidebarHost` 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.
- */
-export function describeSidebarHostContract(
-  name: string,
-  makeHarness: SidebarHostHarnessFactory,
-  capabilities: readonly SidebarHostCapability[],
-): void {
-  const has = (capability: SidebarHostCapability) => capabilities.includes(capability);
-
-  describe(`SidebarHost contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const harness = await makeHarness(BACKEND);
-      cleanup.push(() => harness.dispose?.());
-      return harness;
-    };
-
-    it('offers exactly its capabilities; the members it leaves out are undefined', async () => {
-      const { host } = await setup();
-      for (const capability of CAPABILITIES) {
-        const member = host[capability];
-        expect(member === undefined, capability).toBe(!has(capability));
-      }
-    });
-
-    it.skipIf(!has('revealPath'))('reveals a folder', async () => {
-      const { host, control } = await setup();
-      await expect(host.revealPath!('/repo/app')).resolves.toBeUndefined();
-      expect(control.revealed?.()).toEqual(['/repo/app']);
-    });
-
-    it.skipIf(!has('openWindow'))('opens a session in each kind of window', async () => {
-      const { host, control } = await setup();
-      await host.openWindow!('s1', 'chat+panels');
-      await host.openWindow!('s1', 'panels');
-      expect(control.windows?.()).toEqual([
-        { sessionId: 's1', mode: 'chat+panels' },
-        { sessionId: 's1', mode: 'panels' },
-      ]);
-    });
-
-    it.skipIf(!has('openHostSettings'))("opens a host's settings", async () => {
-      const { host, control } = await setup();
-      await expect(host.openHostSettings!('box')).resolves.toBeUndefined();
-      expect(control.hostSettingsOpened?.()).toEqual(['box']);
-    });
-
-    it.skipIf(!has('environment'))("lists a session's environment commands, none for another", async () => {
-      const { host } = await setup();
-      expect(await host.environment!.actions('s1')).toEqual(BACKEND.environments.s1!.actions);
-      expect(await host.environment!.actions('s2')).toEqual([]);
-    });
-
-    it.skipIf(!has('environment'))('runs a command and answers what to tell the user and what to open', async () => {
-      const { host } = await setup();
-      expect(await host.environment!.run('s1', 'push')).toEqual({ message: 'Pushed zidane/ab12 to origin.' });
-      expect(await host.environment!.run('s1', 'pr')).toEqual({
-        message: 'Opened #12.',
-        url: 'https://github.com/o/r/pull/12',
-      });
-    });
-
-    it.skipIf(!has('environment'))('rejects a command the environment does not offer', async () => {
-      const { host } = await setup();
-      await expect(host.environment!.run('s1', 'nope')).rejects.toBeTruthy();
-    });
-
-    it.skipIf(!has('environment'))('sets an environment up again', async () => {
-      const { host, control } = await setup();
-      await expect(host.environment!.retry('s1')).resolves.toBeUndefined();
-      expect(control.retried?.()).toEqual(['s1']);
-    });
-
-    it.skipIf(!has('badges'))(
-      "reads several sessions' badges at once, none for a session without artifacts",
-      async () => {
-        const { host } = await setup();
-        expect(await host.badges!.read(['s1', 's2'])).toEqual({ s1: BACKEND.badges.s1, s2: [] });
-      },
-    );
-
-    it.skipIf(!has('badges'))("tells when a session's artifacts or the badge kinds change", async () => {
-      const { host, control } = await setup();
-      const changed: string[] = [];
-      let kinds = 0;
-      const offArtifacts = host.badges!.onArtifactsChanged!((sessionId) => changed.push(sessionId));
-      const offKinds = host.badges!.onRegistryChanged!(() => (kinds += 1));
-      control.changeArtifacts?.('s1');
-      control.changeKinds?.();
-      await expect.poll(() => [changed, kinds]).toEqual([['s1'], 1]);
-      offArtifacts();
-      offKinds();
-    });
-  });
-}