zidane-ui 9.1.1 → 9.1.3

package/src/machines/testing/contract.ts

@@ -1,617 +0,0 @@
-/**
- * What every `MachinesHost` implementation does alike, as a vitest suite: the in-memory fixture
- * (`createFixtureMachinesHost`), zidane-server (`createServerMachinesHost`), the desktop app's IPC
- * host.
- *
- * An implementation's test calls {@link describeMachinesHostContract} with a harness factory. The
- * contract hands it a {@link MachinesHostContractBackend}: the server under test (its id, name and
- * version), its machines, self-update and tokens, this computer's links and the local daemon, read at
- * each call, and the recorders the backend calls when an action reaches it. The harness builds the host
- * over a backend that does that (a fake WebSocket server, a mocked IPC bridge) and pushes what a backend
- * pushes: a machine coming online or going offline. The capabilities list says which optional members
- * the host offers: the suite checks that the others are undefined and skips what needs them.
- *
- *   describeMachinesHostContract('createServerMachinesHost', (backend) => ({ host, pushMachineStatus }), [
- *     'hosts', 'machines', 'updates',
- *   ]);
- */
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import type {
-  DaemonStatus,
-  HostCheckResult,
-  MachineInfo,
-  MachineLinksStatus,
-  MachinesAction,
-  MachinesHost,
-  ServerToken,
-  ServerTokenScope,
-  ServerUpdateStatus,
-} from '../headless/host';
-import type { SessionPresence } from '../headless/presence';
-import type { HostCapabilities } from 'zidane/chat/pure';
-
-/** An optional `MachinesHost` member, by its path. */
-export type MachinesHostCapability =
-  | 'hosts'
-  | 'refreshHosts'
-  | 'retry'
-  | 'testHost'
-  | 'addHost'
-  | 'renameHost'
-  | 'setHostUrl'
-  | 'removeHost'
-  | 'savedHosts'
-  | 'machines'
-  | 'machines.forget'
-  | 'machines.invite'
-  | 'links'
-  | 'links.shareStart'
-  | 'links.shareStop'
-  | 'links.useServer'
-  | 'pickFolder'
-  | 'updates'
-  | 'updates.check'
-  | 'updates.install'
-  | 'updates.configure'
-  | 'tokens'
-  | 'tokens.create'
-  | 'tokens.revoke'
-  | 'tokens.onChanged'
-  | 'daemon'
-  | 'daemon.reconnect'
-  | 'daemon.restart'
-  | 'daemon.stopRun'
-  | 'daemon.relaunchApp'
-  | 'presence'
-  | 'capabilities'
-  | 'permitted';
-
-const CAPABILITIES: readonly MachinesHostCapability[] = [
-  'hosts',
-  'refreshHosts',
-  'retry',
-  'testHost',
-  'addHost',
-  'renameHost',
-  'setHostUrl',
-  'removeHost',
-  'savedHosts',
-  'machines',
-  'machines.forget',
-  'machines.invite',
-  'links',
-  'links.shareStart',
-  'links.shareStop',
-  'links.useServer',
-  'pickFolder',
-  'updates',
-  'updates.check',
-  'updates.install',
-  'updates.configure',
-  'tokens',
-  'tokens.create',
-  'tokens.revoke',
-  'tokens.onChanged',
-  'daemon',
-  'daemon.reconnect',
-  'daemon.restart',
-  'daemon.stopRun',
-  'daemon.relaunchApp',
-  'presence',
-  'capabilities',
-  'permitted',
-];
-
-const OBJECTS = new Set<MachinesHostCapability>([
-  'hosts',
-  'savedHosts',
-  'machines',
-  'links',
-  'updates',
-  'tokens',
-  'daemon',
-  'presence',
-  'permitted',
-]);
-
-/** What the backend behind the host holds, and what it records. */
-export interface MachinesHostContractBackend {
-  /**
-   * The server under test, as its backend reports it. Its id is the one the suite passes to the host; the registry
-   * (`savedHosts`) lists it with its dates.
-   */
-  server: { id: string; name: string; url: string; version: string; addedAt: number; lastConnectedAt: number };
-  /** The server's machines. Read at each listing; the harness changes a status before it pushes. */
-  machines: MachineInfo[];
-  /** The server's self-update. Read at each status; {@link updated} changes it. */
-  update: ServerUpdateStatus;
-  /** The server's tokens. Read at each listing; {@link created} and {@link revoked} change it. */
-  tokens: ServerToken[];
-  /** This computer's links. Read at each status; the link recorders change it. */
-  links: MachineLinksStatus;
-  /** The local daemon's status. */
-  daemon: DaemonStatus;
-  /** The folder the native dialog answers. */
-  folder: string;
-  /** What the server can do. The backend counts the probes that asked to refresh in {@link capabilityRefreshes}. */
-  capabilities: HostCapabilities;
-  /** How many capability reads asked for a fresh probe. */
-  capabilityRefreshes: number;
-  /** Every live session's presence. Read at each listing; the harness changes it before it pushes. */
-  presence: SessionPresence[];
-  /** The backend calls this when a retry reaches it. */
-  retried(hostId: string): void;
-  /** The backend calls this when a test reaches it, and answers with what it returns. */
-  tested(target: { id: string } | { url: string; token: string }): HostCheckResult;
-  /** The backend calls this when an add reaches it. */
-  added(input: { url: string; token: string; name?: string }): HostCheckResult;
-  /** The backend calls this when a rename reaches it. */
-  renamed(id: string, name: string): HostCheckResult;
-  /** The backend calls this when a URL change reaches it. */
-  urlChanged(id: string, url: string): HostCheckResult;
-  /** The backend calls this when a removal reaches it. */
-  removed(id: string): void;
-  /** The backend calls this when a forget reaches it: the machine leaves {@link machines}. */
-  forgot(machineId: string): void;
-  /** The backend calls this when a join code is asked for, and answers with what it returns. */
-  invited(params: { name?: string; ttlMs?: number }): { code: string; expiresAt: number };
-  /** The backend calls this when an update action reaches it: {@link update} changes. */
-  updated(action: 'check' | 'install' | 'configure', enabled?: boolean): void;
-  /** The backend calls this when a token is created, and answers with what it returns. */
-  created(name: string, scope: ServerTokenScope): ServerToken & { token: string };
-  /** The backend calls this when a revoke reaches it. */
-  revoked(id: string): void;
-  /** The backend calls this when a link action reaches it: {@link links} changes. */
-  linked(action: 'shareStart' | 'shareStop' | 'useServer', detail?: unknown): void;
-  /** The backend calls this when a daemon action reaches it. */
-  daemonCalled(action: 'reconnect' | 'restart' | 'stopRun' | 'relaunchApp', detail?: unknown): void;
-}
-
-/** A host built over a contract backend, and the pushes its backend can make. */
-export interface MachinesHostHarness {
-  /** The host under test. */
-  host: MachinesHost;
-  /** Sets a machine's status in the backend and pushes the change, as the backend does. */
-  pushMachineStatus(machineId: string, status: 'online' | 'offline'): void;
-  /** Sets the backend's presence and pushes the snapshot, as the backend does (needed for `presence`). */
-  pushPresence?(sessions: SessionPresence[]): void;
-  /** Adds a token elsewhere (another page, the CLI) and says so, as the backend does (needed for `tokens.onChanged`). */
-  pushTokenCreated?(name: string): void;
-  /** Closes connections and listeners after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type MachinesHostHarnessFactory = (
-  backend: MachinesHostContractBackend,
-) => MachinesHostHarness | Promise<MachinesHostHarness>;
-
-const machine = (id: string, name: string, status: 'online' | 'offline'): MachineInfo => ({
-  id,
-  name,
-  roots: [{ path: `/home/${name}` }],
-  status,
-  lastSeen: 1_700_000_000_000,
-});
-
-function contractBackend() {
-  const calls: { action: string; detail?: unknown }[] = [];
-  const record = (action: string, detail?: unknown) => calls.push({ action, detail });
-  const backend: MachinesHostContractBackend = {
-    server: {
-      id: 'srv-1',
-      name: 'Box',
-      url: 'wss://box.example:4280',
-      version: '9.9.9',
-      addedAt: 1_690_000_000_000,
-      lastConnectedAt: 1_700_000_000_000,
-    },
-    machines: [machine('m-1', 'laptop', 'online'), machine('m-2', 'desk', 'offline')],
-    update: { enabled: true, supported: true, current: '9.9.9', latest: '10.0.0', state: 'idle' },
-    tokens: [{ id: 'tok_1', name: 'phone', scope: 'chat', createdAt: 1_700_000_000_000 }],
-    links: { shares: [], uses: [] },
-    daemon: {
-      enabled: true,
-      state: 'connected',
-      socketPath: '/tmp/zidane.sock',
-      window: { protocolVersion: 9, buildId: 'b' },
-      daemon: { pid: 42, protocolVersion: 9, startedAt: 1_700_000_000_000 },
-      sessions: [],
-    },
-    folder: '/home/me/project',
-    capabilities: {
-      os: { platform: 'linux', arch: 'x64', release: '6.8' },
-      tools: [{ name: 'git', found: true, version: 'git version 2.45.0' }],
-      sandbox: { ok: true, backend: 'bwrap' },
-      environments: [{ kind: 'local', label: 'Local', available: true }],
-      allows: { remoteInstalls: true, asMachine: false, sync: true, clone: true, createFolders: true },
-      workspace: { roots: ['/data'], freeBytes: 42 * 1024 ** 3 },
-      probedAt: 1,
-    },
-    capabilityRefreshes: 0,
-    presence: [
-      { sessionId: 's-1', windows: 1, running: true, attention: false },
-      { sessionId: 's-2', windows: 0, running: false, attention: true },
-    ],
-    retried: (hostId) => record('retry', hostId),
-    tested(target) {
-      record('test', target);
-      return { ok: true, name: backend.server.name, serverVersion: backend.server.version, latencyMs: 3 };
-    },
-    added(input) {
-      record('add', input);
-      return { ok: true, name: input.name ?? 'new' };
-    },
-    renamed(id, name) {
-      record('rename', { id, name });
-      return { ok: true, name };
-    },
-    urlChanged(id, url) {
-      record('setUrl', { id, url });
-      return { ok: true, name: backend.server.name, serverVersion: backend.server.version, latencyMs: 3 };
-    },
-    removed: (id) => record('remove', id),
-    forgot(machineId) {
-      record('forget', machineId);
-      backend.machines = backend.machines.filter((m) => m.id !== machineId);
-    },
-    invited(params) {
-      record('invite', params);
-      return { code: 'K7Q2-9XPM', expiresAt: 1_700_000_600_000 };
-    },
-    updated(action, enabled) {
-      record(`update.${action}`, enabled);
-      if (action === 'configure') backend.update = { ...backend.update, enabled: enabled ?? backend.update.enabled };
-      // Off, a check downloads the newer release and reports it ready.
-      else if (action === 'check')
-        backend.update = {
-          ...backend.update,
-          state: !backend.update.enabled && backend.update.latest !== backend.update.current ? 'ready' : 'idle',
-          lastCheckAt: 1_700_000_000_000,
-        };
-      else backend.update = { ...backend.update, state: 'installing' };
-    },
-    created(name, scope) {
-      record('token.create', { name, scope });
-      const token = { id: `tok_${backend.tokens.length + 1}`, name, scope, createdAt: 1_700_000_000_000 };
-      backend.tokens = [...backend.tokens, token];
-      return { ...token, token: 'zds_secret' };
-    },
-    revoked(id) {
-      record('token.revoke', id);
-      backend.tokens = backend.tokens.map((t) => (t.id === id ? { ...t, revokedAt: 1_700_000_000_001 } : t));
-    },
-    linked(action, detail) {
-      record(`link.${action}`, detail);
-      const hostId = backend.server.id;
-      if (action === 'shareStart') {
-        const { name, roots } = detail as { name: string; roots: string[] };
-        backend.links = { ...backend.links, shares: [{ hostId, name, roots, state: 'connected' }] };
-      } else if (action === 'shareStop') backend.links = { ...backend.links, shares: [] };
-      else
-        backend.links = {
-          ...backend.links,
-          uses: detail ? [{ hostId, state: 'connected', machineName: backend.server.name }] : [],
-        };
-    },
-    daemonCalled: (action, detail) => record(`daemon.${action}`, detail),
-  };
-  return { backend, calls };
-}
-
-const waitFor = <T>(check: () => T) => vi.waitFor(check, { timeout: 3000, interval: 2 });
-
-const ALL_ACTIONS: readonly MachinesAction[] = [
-  'machines.list',
-  'machines.forget',
-  'machines.invite',
-  'update.status',
-  'update.manage',
-  'tokens.list',
-  'tokens.manage',
-];
-
-/**
- * Declares the shared `MachinesHost` 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 and records what it is given, once per test.
- * @param capabilities - The optional members the host offers. Every other optional member must be undefined.
- */
-export function describeMachinesHostContract(
-  name: string,
-  makeHarness: MachinesHostHarnessFactory,
-  capabilities: readonly MachinesHostCapability[],
-): void {
-  const has = (...needed: MachinesHostCapability[]) => needed.every((c) => capabilities.includes(c));
-
-  describe(`MachinesHost contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const recorded = contractBackend();
-      const harness = await makeHarness(recorded.backend);
-      cleanup.push(() => harness.dispose?.());
-      const id = recorded.backend.server.id;
-      return { ...recorded, ...harness, id };
-    };
-    const calls = (recorded: { action: string; detail?: unknown }[], action: string) =>
-      recorded.filter((c) => c.action === action);
-
-    it('offers exactly its capabilities; the members it leaves out are undefined', async () => {
-      const { host } = await setup();
-      const member = (capability: MachinesHostCapability): unknown => {
-        const [head, tail] = capability.split('.') as [string, string | undefined];
-        const top = (host as unknown as Record<string, unknown>)[head];
-        return tail ? (top as Record<string, unknown> | undefined)?.[tail] : top;
-      };
-      for (const capability of CAPABILITIES) {
-        const value = member(capability);
-        if (!has(capability)) expect(value, capability).toBeUndefined();
-        else expect(typeof value, capability).toBe(OBJECTS.has(capability) ? 'object' : 'function');
-      }
-    });
-
-    it.skipIf(!has('hosts'))('lists the server it talks to, connected, with its version', async () => {
-      const { host, id, backend } = await setup();
-      cleanup.push(host.hosts!.subscribe(() => {}));
-      await waitFor(() =>
-        expect(host.hosts!.get().hosts.find((h) => h.id === id)).toMatchObject({
-          kind: 'server',
-          name: backend.server.name,
-          status: 'connected',
-          serverVersion: backend.server.version,
-        }),
-      );
-    });
-
-    it.skipIf(!has('savedHosts'))('reads the saved servers with their dates, and again on refresh', async () => {
-      const { host, id, backend } = await setup();
-      const saved = host.savedHosts!;
-      cleanup.push(saved.state.subscribe(() => {}));
-      await waitFor(() => expect(saved.state.get().status).toBe('ready'));
-      expect(saved.state.get().error).toBeNull();
-      expect(saved.state.get().hosts.find((h) => h.id === id)).toMatchObject({
-        name: backend.server.name,
-        addedAt: backend.server.addedAt,
-        lastConnectedAt: backend.server.lastConnectedAt,
-      });
-      backend.server.lastConnectedAt += 1000;
-      await saved.refresh();
-      await waitFor(() =>
-        expect(saved.state.get().hosts.find((h) => h.id === id)?.lastConnectedAt).toBe(backend.server.lastConnectedAt),
-      );
-    });
-
-    it.skipIf(!has('retry'))('retries a server', async () => {
-      const { host, id, calls: recorded } = await setup();
-      await host.retry!(id);
-      await waitFor(() => expect(calls(recorded, 'retry').map((c) => c.detail)).toEqual([id]));
-    });
-
-    it.skipIf(!has('testHost', 'addHost', 'renameHost', 'removeHost'))(
-      'tests, adds, renames and removes a server, answering as data',
-      async () => {
-        const { host, id, calls: recorded, backend } = await setup();
-        const tested = await host.testHost!({ id });
-        expect(tested).toMatchObject({ ok: true, name: backend.server.name, serverVersion: backend.server.version });
-        expect(await host.addHost!({ url: 'wss://new.example', token: 'zds_x', name: 'New' })).toMatchObject({
-          ok: true,
-          name: 'New',
-        });
-        expect(await host.renameHost!(id, 'Attic')).toMatchObject({ ok: true, name: 'Attic' });
-        await host.removeHost!(id);
-        await waitFor(() => expect(calls(recorded, 'remove').map((c) => c.detail)).toEqual([id]));
-        expect(calls(recorded, 'add')[0]?.detail).toMatchObject({ url: 'wss://new.example', token: 'zds_x' });
-        expect(calls(recorded, 'rename')[0]?.detail).toEqual({ id, name: 'Attic' });
-      },
-    );
-
-    it.skipIf(!has('setHostUrl'))('moves a saved server to a new URL, answering as data', async () => {
-      const { host, id, calls: recorded, backend } = await setup();
-      expect(await host.setHostUrl!(id, 'wss://box.example:8443')).toMatchObject({
-        ok: true,
-        name: backend.server.name,
-      });
-      expect(calls(recorded, 'setUrl')[0]?.detail).toEqual({ id, url: 'wss://box.example:8443' });
-    });
-
-    it.skipIf(!has('machines'))("lists the server's machines and follows their status", async () => {
-      const { host, id, pushMachineStatus } = await setup();
-      const list = host.machines!.list(id);
-      expect(host.machines!.list(id)).toBe(list);
-      cleanup.push(list.state.subscribe(() => {}));
-      cleanup.push(host.machines!.online.subscribe(() => {}));
-      await waitFor(() => expect(list.state.get().status).toBe('ready'));
-      expect(list.state.get().machines.map((m) => [m.name, m.status])).toEqual([
-        ['laptop', 'online'],
-        ['desk', 'offline'],
-      ]);
-      pushMachineStatus('m-2', 'online');
-      await waitFor(() => expect(list.state.get().machines.find((m) => m.id === 'm-2')?.status).toBe('online'));
-      expect(host.machines!.online.get().has('desk')).toBe(true);
-      pushMachineStatus('m-2', 'offline');
-      await waitFor(() => expect(host.machines!.online.get().has('desk')).toBe(false));
-    });
-
-    it.skipIf(!has('machines.forget'))('forgets a machine', async () => {
-      const { host, id, calls: recorded } = await setup();
-      const list = host.machines!.list(id);
-      cleanup.push(list.state.subscribe(() => {}));
-      await waitFor(() => expect(list.state.get().status).toBe('ready'));
-      await host.machines!.forget!(id, 'm-1');
-      await list.refresh();
-      expect(list.state.get().machines.map((m) => m.id)).toEqual(['m-2']);
-      expect(calls(recorded, 'forget').map((c) => c.detail)).toEqual(['m-1']);
-    });
-
-    it.skipIf(!has('machines.invite'))(
-      "makes a join code for a new machine: the server's URL and the code, and when it stops working",
-      async () => {
-        const { host, id, calls: recorded, backend } = await setup();
-        expect(await host.machines!.invite!(id, { name: 'gpu-box' })).toEqual({
-          code: 'K7Q2-9XPM',
-          expiresAt: 1_700_000_600_000,
-          join: `${backend.server.url}#K7Q2-9XPM`,
-        });
-        expect(calls(recorded, 'invite')[0]?.detail).toMatchObject({ name: 'gpu-box' });
-      },
-    );
-
-    it.skipIf(!has('machines.invite'))('a join code without a name sends none: the machine gives its own', async () => {
-      const { host, id, calls: recorded } = await setup();
-      await host.machines!.invite!(id);
-      expect(calls(recorded, 'invite')[0]?.detail).not.toHaveProperty('name');
-    });
-
-    it.skipIf(!has('links'))("reads this computer's links and changes them", async () => {
-      const { host, id, backend } = await setup();
-      const links = host.links!;
-      cleanup.push(links.state.subscribe(() => {}));
-      await links.refresh();
-      expect(links.state.get()).toEqual({ shares: [], uses: [] });
-      if (links.shareStart) {
-        const result = await links.shareStart(id, 'me', ['/home/me']);
-        expect(result).toMatchObject({ ok: true });
-        await waitFor(() => expect(links.state.get().shares.map((s) => [s.hostId, s.name])).toEqual([[id, 'me']]));
-      }
-      if (links.shareStop) {
-        await links.shareStop(id);
-        await waitFor(() => expect(links.state.get().shares).toEqual([]));
-      }
-      if (links.useServer) {
-        await links.useServer(id, true);
-        await waitFor(() =>
-          expect(links.state.get().uses).toEqual([
-            { hostId: id, state: 'connected', machineName: backend.server.name },
-          ]),
-        );
-      }
-    });
-
-    it.skipIf(!has('pickFolder'))('picks a folder', async () => {
-      const { host, backend } = await setup();
-      expect(await host.pickFolder!()).toBe(backend.folder);
-    });
-
-    it.skipIf(!has('updates'))("reads the server's self-update and acts on it", async () => {
-      const { host, id, calls: recorded } = await setup();
-      const updates = host.updates!;
-      expect(await updates.status(id)).toMatchObject({
-        enabled: true,
-        supported: true,
-        current: '9.9.9',
-        state: 'idle',
-      });
-      if (updates.configure) expect(await updates.configure(id, false)).toMatchObject({ enabled: false });
-      if (updates.check) expect((await updates.check(id)).current).toBe('9.9.9');
-      if (updates.install) expect((await updates.install(id)).state).toBe('installing');
-      const expected = [
-        ...(has('updates.configure') ? ['update.configure'] : []),
-        ...(has('updates.check') ? ['update.check'] : []),
-        ...(has('updates.install') ? ['update.install'] : []),
-      ];
-      expect(recorded.map((c) => c.action).filter((a) => a.startsWith('update.'))).toEqual(expected);
-    });
-
-    it.skipIf(!has('updates.check', 'updates.install', 'updates.configure'))(
-      'auto-update off: a check reports the release ready, and install installs it',
-      async () => {
-        const { host, id } = await setup();
-        const updates = host.updates!;
-        await updates.configure!(id, false);
-        expect(await updates.check!(id)).toMatchObject({ enabled: false, latest: '10.0.0', state: 'ready' });
-        expect(await updates.status(id)).toMatchObject({ latest: '10.0.0', state: 'ready' });
-        expect((await updates.install!(id)).state).toBe('installing');
-      },
-    );
-
-    it.skipIf(!has('tokens'))("lists the server's tokens, creates and revokes one", async () => {
-      const { host, id } = await setup();
-      const tokens = host.tokens!;
-      expect((await tokens.list(id)).map((t) => [t.id, t.name, t.scope])).toEqual([['tok_1', 'phone', 'chat']]);
-      if (tokens.create) {
-        const created = await tokens.create(id, 'laptop', 'admin');
-        expect(created).toMatchObject({ name: 'laptop', scope: 'admin' });
-        expect(typeof created.token).toBe('string');
-        expect((await tokens.list(id)).map((t) => t.name)).toContain('laptop');
-      }
-      if (tokens.revoke) {
-        await tokens.revoke(id, 'tok_1');
-        expect((await tokens.list(id)).find((t) => t.id === 'tok_1')?.revokedAt).toBeTypeOf('number');
-      }
-    });
-
-    it.skipIf(!has('tokens.onChanged'))('hears when the tokens change elsewhere', async () => {
-      const { host, backend, id, pushTokenCreated } = await setup();
-      const heard = vi.fn();
-      cleanup.push(host.tokens!.onChanged!(id, heard));
-      pushTokenCreated!('from the CLI');
-      await waitFor(() => expect(heard).toHaveBeenCalled());
-      expect(backend.tokens.map((t) => t.name)).toContain('from the CLI');
-    });
-
-    it.skipIf(!has('capabilities'))('reads what the server can do, and probes again when asked', async () => {
-      const { host, backend, id } = await setup();
-      const caps = await host.capabilities!(id);
-      expect(caps.os.platform).toBe('linux');
-      expect(caps.tools.find((t) => t.name === 'git')?.found).toBe(true);
-      expect(backend.capabilityRefreshes).toBe(0);
-      await host.capabilities!(id, { refresh: true });
-      expect(backend.capabilityRefreshes).toBe(1);
-    });
-
-    it.skipIf(!has('presence'))('follows per-session presence, keeping the entries that did not change', async () => {
-      const { host, pushPresence, backend } = await setup();
-      const presence = host.presence!;
-      const onMap = vi.fn();
-      cleanup.push(presence.sessions.subscribe(onMap));
-      const s1 = presence.session('s-1');
-      const onS1 = vi.fn();
-      cleanup.push(s1.subscribe(onS1));
-      await waitFor(() => expect(presence.sessions.get().size).toBe(2));
-      expect(s1.get()).toMatchObject({ windows: 1, running: true });
-      expect(presence.session('s-2').get()).toMatchObject({ attention: true });
-      expect(presence.session('s-9').get()).toBeNull();
-      if (!pushPresence) return;
-      const before = s1.get();
-      onS1.mockClear();
-      pushPresence([backend.presence[0]!, { sessionId: 's-2', windows: 1, running: true, attention: false }]);
-      await waitFor(() => expect(presence.session('s-2').get()).toMatchObject({ running: true, attention: false }));
-      expect(s1.get()).toBe(before);
-      expect(onS1).not.toHaveBeenCalled();
-      pushPresence([]);
-      await waitFor(() => expect(s1.get()).toBeNull());
-    });
-
-    it.skipIf(!has('daemon'))('reads the daemon and runs its recovery actions', async () => {
-      const { host, calls: recorded } = await setup();
-      const daemon = host.daemon!;
-      expect(['connected', 'connecting', 'disconnected']).toContain(daemon.health.get());
-      expect((await daemon.status())?.state).toBe('connected');
-      if (daemon.reconnect) expect((await daemon.reconnect()).state).toBe('connected');
-      if (daemon.restart) await daemon.restart(false);
-      if (daemon.stopRun) await daemon.stopRun('all');
-      const expected = [
-        ...(has('daemon.reconnect') ? ['daemon.reconnect'] : []),
-        ...(has('daemon.restart') ? ['daemon.restart'] : []),
-        ...(has('daemon.stopRun') ? ['daemon.stopRun'] : []),
-      ];
-      await waitFor(() =>
-        expect(recorded.map((c) => c.action).filter((a) => a.startsWith('daemon.'))).toEqual(expected),
-      );
-    });
-
-    it.skipIf(!has('permitted'))('permits everything a full-access token may do', async () => {
-      const { host } = await setup();
-      cleanup.push(host.permitted!.subscribe(() => {}));
-      await waitFor(() => expect([...(host.permitted!.get() ?? [])].sort()).toEqual([...ALL_ACTIONS].sort()));
-    });
-  });
-}
-
-export * from './sync.contract';

package/src/machines/testing/index.ts

@@ -1,7 +0,0 @@
-/**
- * `zidane-ui/machines/testing`: a `MachinesHost` that runs in memory
- * (`createFixtureMachinesHost`) and demo hosts, machines, tokens and a daemon,
- * for docs, demos and an app's own tests. Not for production hosts.
- */
-export * from '../headless/fixture-host';
-export * from '../headless/fixtures';