zidane-ui 9.0.4 → 9.1.3

package/src/files/headless/search.ts

@@ -1,23 +0,0 @@
-/**
- * Text matching for search in files and in changes: the offsets of every
- * occurrence of a query in a line, case-sensitive or not.
- */
-import type { TextMatchOptions } from './host';
-
-/**
- * Every occurrence of `query` in `text`, as UTF-16 offsets.
- *
- * @param text - The text to search.
- * @param query - What to find (empty: nothing).
- * @param opts - Whether case matters.
- */
-export function matchRanges(text: string, query: string, opts: TextMatchOptions): { start: number; end: number }[] {
-  if (!query) return [];
-  const hay = opts.caseSensitive ? text : text.toLowerCase();
-  const needle = opts.caseSensitive ? query : query.toLowerCase();
-  const out: { start: number; end: number }[] = [];
-  for (let at = hay.indexOf(needle); at !== -1; at = hay.indexOf(needle, at + needle.length)) {
-    out.push({ start: at, end: at + needle.length });
-  }
-  return out;
-}

package/src/files/headless/view.ts

@@ -1,114 +0,0 @@
-/**
- * What the Files and Diffs tabs keep per view and what they hand to the app:
- * the scope's folder and identity, the per-scope layout (open tabs, the
- * active file, the tree toggles and width) and the chat a view adds to.
- */
-import type { Readable } from '../../chat/headless/store';
-import type { FilesScope } from './host';
-
-/**
- * The scope's folder for file views: the session's workspace URI when its files are elsewhere, else its `cwd`.
- *
- * @param scope - The view's scope.
- */
-export function filesRootOf(scope: FilesScope): string {
-  return scope.workspace ?? scope.cwd;
-}
-
-/**
- * The scope's identity: the session when bound, else `draft:<id>` or `project:<root>`.
- *
- * @param scope - The view's scope.
- */
-export function filesScopeKey(scope: FilesScope): string {
-  if (scope.session) return scope.session;
-  if (scope.draft) return `draft:${scope.draft}`;
-  return `project:${scope.root}`;
-}
-
-/** What the Files tab keeps per scope. */
-export interface FilesLayout {
-  /** The open files, in tab order. */
-  filesOpen: readonly string[];
-  /** The active file. */
-  filesActive: string | null;
-  /** Gitignored files are listed. */
-  filesShowIgnored: boolean;
-  /** The tree's width (`null`: the default). */
-  filesTreeWidth: number | null;
-  /** The tree is shown. */
-  filesTreeOpen: boolean;
-  /** The tree lists changed files only. */
-  filesChangedOnly: boolean;
-}
-
-/** A fresh scope's layout. */
-export const DEFAULT_FILES_LAYOUT: FilesLayout = {
-  filesOpen: [],
-  filesActive: null,
-  filesShowIgnored: false,
-  filesTreeWidth: null,
-  filesTreeOpen: true,
-  filesChangedOnly: false,
-};
-
-/** Where a scope's layout lives: read with `get`, follow with `subscribe`, change with `update`. */
-export interface FilesLayoutStore extends Readable<FilesLayout> {
-  /** Merges `patch` into the layout. */
-  update(patch: Partial<FilesLayout>): void;
-}
-
-/**
- * A layout that lasts as long as the store: for an app that keeps none.
- *
- * @param initial - Where it starts.
- */
-export function createMemoryFilesLayout(initial: Partial<FilesLayout> = {}): FilesLayoutStore {
-  let state: FilesLayout = { ...DEFAULT_FILES_LAYOUT, ...initial };
-  const listeners = new Set<() => void>();
-  return {
-    get: () => state,
-    subscribe(onChange) {
-      listeners.add(onChange);
-      return () => {
-        listeners.delete(onChange);
-      };
-    },
-    update(patch) {
-      state = { ...state, ...patch };
-      for (const l of [...listeners]) l();
-    },
-  };
-}
-
-/** The chat a view adds to: the composer receiving the view's scope. */
-export interface FilesChatTarget {
-  /** Mentions a path (relative to the folder) in the composer. */
-  mention(path: string): void;
-  /** Attaches a text (a snippet, a review comment, a finding) to the composer under `name`. */
-  attach(name: string, text: string): void;
-}
-
-/** What next/previous/close/find keys do inside a tab (the app routes them by focus). */
-export interface FilesKeyScope {
-  /** `1` next, `-1` previous. Returns false when there was nothing to move to. */
-  step: (direction: 1 | -1) => boolean;
-  /** Closes one thing inside the tab. False when nothing is left to close. */
-  close: () => boolean;
-  /** `file`: find in the file or diff on screen; `files`: search across files. False when there is nothing to search. */
-  find?: (mode: 'file' | 'files') => boolean;
-}
-
-/**
- * The next index when stepping `direction` through `length` items from `current` (-1: none), wrapping; -1 when
- * there are none.
- *
- * @param current - The current index, or -1.
- * @param length - How many items.
- * @param direction - `1` next, `-1` previous.
- */
-export function steppedIndex(current: number, length: number, direction: 1 | -1): number {
-  if (length === 0) return -1;
-  if (current < 0) return direction === 1 ? 0 : length - 1;
-  return (current + direction + length) % length;
-}

package/src/files/headless/workspace-diff.ts

@@ -1,82 +0,0 @@
-/**
- * Pure comparisons behind the Files tab's refreshes: a tool burst re-lists
- * the workspace and re-reads git status, and most bursts change neither.
- * Keeping the previous array when nothing moved lets every memo and effect
- * downstream (tree paths, `resetPaths`, git decorations) skip its work.
- */
-import type { SessionEditEvent } from '../../session/headless/session-diffs';
-import type { GitStatusEntry, WorkspaceEntry, WorkspaceFile } from './host';
-
-export function sameEntries(a: readonly WorkspaceEntry[] | null, b: readonly WorkspaceEntry[] | null): boolean {
-  if (a === b) return true;
-  if (!a || !b || a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.path !== y.path || x.kind !== y.kind || Boolean(x.ignored) !== Boolean(y.ignored)) return false;
-  }
-  return true;
-}
-
-export function sameStatus(a: readonly GitStatusEntry[], b: readonly GitStatusEntry[]): boolean {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) if (a[i].path !== b[i].path || a[i].status !== b[i].status) return false;
-  return true;
-}
-
-export function sameSet(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean {
-  if (a === b) return true;
-  if (a.size !== b.size) return false;
-  for (const x of a) if (!b.has(x)) return false;
-  return true;
-}
-
-/** Paths whose git status appeared, vanished or changed kind between two reads. */
-export function statusDelta(prev: readonly GitStatusEntry[], next: readonly GitStatusEntry[]): Set<string> {
-  const before = new Map(prev.map((e) => [e.path, e.status]));
-  const out = new Set<string>();
-  for (const e of next) {
-    if (before.get(e.path) !== e.status) out.add(e.path);
-    before.delete(e.path);
-  }
-  for (const p of before.keys()) out.add(p);
-  return out;
-}
-
-/**
- * Paths the session's edit events actually changed: the same filter
- * `collectSessionDiffs` applies (an edit whose every hunk was denied or
- * failed changed nothing), without building a unified diff per edit.
- */
-export function editedPath(ev: SessionEditEvent): string | null {
-  const edit = ev.kind === 'tool' ? ev.edit : undefined;
-  if (!edit) return null;
-  const landed = edit.outcomes
-    ? edit.hunks.some((_, i) => edit.outcomes?.[i]?.kind !== 'denied' && edit.outcomes?.[i]?.kind !== 'failed')
-    : edit.hunks.length > 0;
-  return landed ? edit.path : null;
-}
-
-export function editedPaths(events: readonly SessionEditEvent[]): Set<string> {
-  const out = new Set<string>();
-  for (const ev of events) {
-    const p = editedPath(ev);
-    if (p !== null) out.add(p);
-  }
-  return out;
-}
-
-/** A re-read that found the same bytes at the same mtime: keep the old object so viewers skip a render. */
-export function sameFile(a: WorkspaceFile | null | 'missing', b: WorkspaceFile | 'missing'): boolean {
-  if (a === b) return true;
-  if (a === null || a === 'missing' || b === 'missing') return false;
-  return a.mtimeMs === b.mtimeMs && a.size === b.size && a.contents === b.contents && a.truncated === b.truncated;
-}
-
-/** Line count without splitting (a 10k-line file is one pass over the string). */
-export function lineCount(text: string): number {
-  let n = 1;
-  for (let i = text.indexOf('\n'); i !== -1; i = text.indexOf('\n', i + 1)) n++;
-  return n;
-}

package/src/files/index.ts

@@ -1,24 +0,0 @@
-/**
- * `zidane-ui/files`: the Files and Diffs tabs over a `FilesHost`:
- * `FilesProvider` and its hooks, `FilesTab` (the workspace tree beside the
- * open files: viewer, editor, working-tree diff, search in files, find,
- * diagnostics) and `DiffsTab` (the session's edits and the working tree).
- * The React-free model is `zidane-ui/files/headless`.
- */
-export * from './FilesProvider';
-export * from './useFilesLabels';
-export { DiffsTab, FilesTab } from './lazy-tabs';
-export type { FilesTabProps, FilesRevealPosition } from './FilesTab';
-export type { DiffsTabProps } from './DiffsTab';
-export type { FilesKeyScopeHook, SessionEditsHook } from './tab-hooks';
-export {
-  attachmentName,
-  codeAttachmentLabel,
-  fenceFor,
-  parseCodeAttachmentName,
-  serializeTerminalExcerpt,
-  terminalRangeDetail,
-  terminalRangeLabel,
-  type CodeAttachmentInfo,
-  type TerminalExcerpt,
-} from './code-excerpt';

package/src/files/lazy-tabs.tsx

@@ -1,41 +0,0 @@
-/**
- * The entry's `FilesTab` and `DiffsTab`: each loads its tab (and the code
- * editor under it, pierre) on first render, so an app that imports anything
- * from `zidane-ui/files` keeps the editor out of its startup. Nothing renders
- * until the chunk lands; the tab then mounts as it would directly.
- */
-import { lazy, Suspense } from 'react';
-
-import type { DiffsTabProps } from './DiffsTab';
-import type { FilesTabProps } from './FilesTab';
-
-const LazyFilesTab = lazy(() => import('./FilesTab').then((m) => ({ default: m.FilesTab })));
-const LazyDiffsTab = lazy(() => import('./DiffsTab').then((m) => ({ default: m.DiffsTab })));
-
-/**
- * The Files tab: the workspace tree beside the open files (viewer, editor, working-tree diff), search in files,
- * find, diagnostics and language-server findings, over the {@link FilesProvider}'s host. Loads on first render.
- *
- * @param props - The scope, the app's layout store, chat target, hooks and hand-overs.
- */
-export function FilesTab(props: FilesTabProps) {
-  return (
-    <Suspense fallback={null}>
-      <LazyFilesTab {...props} />
-    </Suspense>
-  );
-}
-
-/**
- * The Diffs tab: the session's edits and the working tree against HEAD, a file tree beside virtualised diffs with
- * review comments, find in diffs and search in changes, over the {@link FilesProvider}'s host. Loads on first render.
- *
- * @param props - The scope, the app's hooks, chat target and requests.
- */
-export function DiffsTab(props: DiffsTabProps) {
-  return (
-    <Suspense fallback={null}>
-      <LazyDiffsTab {...props} />
-    </Suspense>
-  );
-}

package/src/files/tab-hooks.ts

@@ -1,37 +0,0 @@
-/**
- * What the app plugs into the Files and Diffs tabs: hooks it passes as props
- * (stable functions, called on every render like any hook), and the chat the
- * views below a tab add to.
- */
-import { createContext, useContext, type RefObject } from 'react';
-
-import type { SessionEditEvent } from '../session/headless/session-diffs';
-import type { FilesChatTarget, FilesKeyScope } from './headless/view';
-
-/**
- * Registers a tab's key scope on its root element (next / previous / close / find), routed by the app's focus
- * handling. A hook: the same function on every render.
- */
-export type FilesKeyScopeHook = (root: RefObject<HTMLElement | null>, scope: FilesKeyScope) => void;
-
-/**
- * A session's edit events (`tool` events carrying an `edit`), as a stable array that changes only when an edit
- * lands (`null`: no session, no edits). A hook: the same function on every render.
- */
-export type SessionEditsHook = (sessionId: string | null) => readonly SessionEditEvent[];
-
-const NO_EDITS: readonly SessionEditEvent[] = [];
-
-/** No session edits: the app passes no hook. */
-export const useNoEdits: SessionEditsHook = () => NO_EDITS;
-
-/** Registers nothing: the app passes no key-scope hook. */
-export const useNoKeyScope: FilesKeyScopeHook = () => {};
-
-/** The chat the views below a tab add to (`null`: none, chat actions show disabled). */
-export const FilesChatContext = createContext<FilesChatTarget | null>(null);
-
-/** The chat the views below a tab add to. */
-export function useFilesChat(): FilesChatTarget | null {
-  return useContext(FilesChatContext);
-}

package/src/files/testing/contract.ts

@@ -1,279 +0,0 @@
-/**
- * What every `FilesHost` implementation does alike, as a vitest suite: the in-memory fixture
- * (`createFixtureFilesHost`), zidane-server's (`createServerFilesHost`), the desktop app's.
- *
- * An implementation's test calls {@link describeFilesHostContract} with a harness factory. The contract hands
- * it a {@link FilesHostContractBackend}: the folder, its text files, its git status and its working-tree
- * patch. The harness builds the host over a backend that holds them (a fixture, a fake server, a mocked IPC
- * bridge) and returns a {@link FilesHostContractControl} 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.
- *
- *   describeFilesHostContract('createServerFilesHost', (backend) => ({ host, control }), ['list', 'read', 'write']);
- */
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { DEFAULT_EDITOR } from '../headless/editor-prefs';
-import type { FilesHost, FilesScope, GitStatusEntry } from '../headless/host';
-
-/** An optional `FilesHost` member. */
-export type FilesHostCapability =
-  | 'list'
-  | 'read'
-  | 'write'
-  | 'entries'
-  | 'search'
-  | 'gitStatus'
-  | 'workingTreeDiff'
-  | 'watch'
-  | 'editorPrefs'
-  | 'diagnostics'
-  | 'lsp'
-  | 'system'
-  | 'mediaUrl';
-
-const CAPABILITIES: readonly FilesHostCapability[] = [
-  'list',
-  'read',
-  'write',
-  'entries',
-  'search',
-  'gitStatus',
-  'workingTreeDiff',
-  'watch',
-  'editorPrefs',
-  'diagnostics',
-  'lsp',
-  'system',
-  'mediaUrl',
-];
-
-/** What the backend behind the host holds. */
-export interface FilesHostContractBackend {
-  /** The folder (absolute). */
-  cwd: string;
-  /** Its text files, by path relative to it. */
-  files: Readonly<Record<string, string>>;
-  /** Its git status. */
-  status: readonly GitStatusEntry[];
-  /** Its working tree against HEAD, as a unified patch. */
-  diff: string;
-}
-
-/** Reads the backend and changes it from outside. */
-export interface FilesHostContractControl {
-  /** A file's text in the backend now, or `undefined`. */
-  file(path: string): string | undefined;
-  /** Another writer changed a file (its version moves). */
-  edit(path: string, text: string): void;
-  /** The folder may have changed (a tool result in it): watchers hear it. Required with `watch`. */
-  touch?(): void;
-}
-
-/** A host built over a backend, the backend's control, and how to tear them down. */
-export interface FilesHostHarness {
-  /** The host under test. */
-  host: FilesHost;
-  /** Reads and changes the backend. */
-  control: FilesHostContractControl;
-  /** Closes listeners after each test. */
-  dispose?(): void;
-}
-
-/** Builds a fresh host (and its backend) for one test. */
-export type FilesHostHarnessFactory = (
-  backend: FilesHostContractBackend,
-) => FilesHostHarness | Promise<FilesHostHarness>;
-
-const CWD = '/work/app';
-const FILES = {
-  'src/a.ts': 'const answer = 42;\nexport default answer;\n',
-  'src/b.ts': 'import answer from "./a";\nconsole.log(answer);\n',
-  'README.md': '# App\n',
-};
-const STATUS: readonly GitStatusEntry[] = [{ path: 'src/a.ts', status: 'modified' }];
-const DIFF = `diff --git a/src/a.ts b/src/a.ts
---- a/src/a.ts
-+++ b/src/a.ts
-@@ -1,2 +1,2 @@
--const answer = 41;
-+const answer = 42;
- export default answer;
-`;
-const SCOPE: FilesScope = { root: CWD, cwd: CWD };
-
-/**
- * Declares the shared `FilesHost` 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 describeFilesHostContract(
-  name: string,
-  makeHarness: FilesHostHarnessFactory,
-  capabilities: readonly FilesHostCapability[],
-): void {
-  const has = (capability: FilesHostCapability) => capabilities.includes(capability);
-
-  describe(`FilesHost contract: ${name}`, () => {
-    const cleanup: (() => void)[] = [];
-    afterEach(() => {
-      for (const done of cleanup.splice(0).reverse()) done();
-    });
-
-    const setup = async () => {
-      const harness = await makeHarness({ cwd: CWD, files: FILES, status: STATUS, diff: DIFF });
-      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) {
-        expect(host[capability] === undefined, capability).toBe(!has(capability));
-      }
-    });
-
-    it.skipIf(!has('list'))("lists the folder's files", async () => {
-      const { host } = await setup();
-      const entries = await host.list!(CWD);
-      const files = entries.filter((e) => e.kind === 'file').map((e) => e.path);
-      expect(files.sort()).toEqual(Object.keys(FILES).sort());
-    });
-
-    it.skipIf(!has('read'))('reads a file with its size and version, and null for a missing one', async () => {
-      const { host } = await setup();
-      const file = await host.read!(CWD, 'src/a.ts');
-      expect(file).toMatchObject({ path: 'src/a.ts', contents: FILES['src/a.ts'], binary: false, truncated: false });
-      expect(file!.size).toBe(new TextEncoder().encode(FILES['src/a.ts']).length);
-      expect(typeof file!.mtimeMs).toBe('number');
-      expect(await host.read!(CWD, 'nope.ts')).toBeNull();
-    });
-
-    it.skipIf(!has('read'))("a file's version moves when another writer changes it", async () => {
-      const { host, control } = await setup();
-      const before = await host.read!(CWD, 'src/b.ts');
-      control.edit('src/b.ts', 'changed\n');
-      const after = await host.read!(CWD, 'src/b.ts');
-      expect(after!.contents).toBe('changed\n');
-      expect(after!.mtimeMs).not.toBe(before!.mtimeMs);
-    });
-
-    it.skipIf(!has('write') || !has('read'))(
-      'writes against the version it read, and the backend holds it',
-      async () => {
-        const { host, control } = await setup();
-        const file = await host.read!(CWD, 'src/a.ts');
-        const result = await host.write!(CWD, 'src/a.ts', 'const answer = 43;\n', file!.mtimeMs);
-        expect(result.ok).toBe(true);
-        expect(control.file('src/a.ts')).toBe('const answer = 43;\n');
-        const again = await host.read!(CWD, 'src/a.ts');
-        expect(again!.contents).toBe('const answer = 43;\n');
-        if (result.ok) expect(again!.mtimeMs).toBe(result.mtimeMs);
-      },
-    );
-
-    it.skipIf(!has('write') || !has('read'))('refuses a write when the file moved since it was read', async () => {
-      const { host, control } = await setup();
-      const file = await host.read!(CWD, 'src/a.ts');
-      control.edit('src/a.ts', 'someone else\n');
-      const result = await host.write!(CWD, 'src/a.ts', 'mine\n', file!.mtimeMs);
-      expect(result).toEqual({ ok: false, reason: 'changed' });
-      expect(control.file('src/a.ts')).toBe('someone else\n');
-    });
-
-    it.skipIf(!has('entries'))('creates files and folders, and refuses a taken name', async () => {
-      const { host, control } = await setup();
-      const entries = host.entries!;
-      expect(await entries.create(CWD, 'src/new/c.ts', 'file')).toEqual({ ok: true, path: 'src/new/c.ts' });
-      expect(control.file('src/new/c.ts')).toBe('');
-      expect(await entries.create(CWD, 'docs', 'dir')).toEqual({ ok: true, path: 'docs' });
-      const taken = await entries.create(CWD, 'src/a.ts', 'file');
-      expect(taken).toMatchObject({ ok: false, reason: 'exists' });
-      expect(control.file('src/a.ts')).toBe(FILES['src/a.ts']);
-      expect(await entries.create(CWD, '../out.ts', 'file')).toMatchObject({ ok: false, reason: 'invalid' });
-      if (has('list')) {
-        const listed = (await host.list!(CWD)).map((e) => e.path);
-        expect(listed).toContain('src/new/c.ts');
-        expect(listed).toContain('docs/');
-      }
-    });
-
-    it.skipIf(!has('entries'))('moves, copies under a free name and removes, never over a taken name', async () => {
-      const { host, control } = await setup();
-      const entries = host.entries!;
-      expect(await entries.move(CWD, 'src/b.ts', 'lib/b.ts')).toEqual({ ok: true, path: 'lib/b.ts' });
-      expect(control.file('lib/b.ts')).toBe(FILES['src/b.ts']);
-      expect(control.file('src/b.ts')).toBeUndefined();
-      expect(await entries.move(CWD, 'lib/b.ts', 'src/a.ts')).toMatchObject({ ok: false, reason: 'exists' });
-      expect(await entries.copy(CWD, 'src/a.ts', 'src')).toEqual({ ok: true, path: 'src/a copy.ts' });
-      expect(control.file('src/a copy.ts')).toBe(FILES['src/a.ts']);
-      expect(await entries.remove(CWD, 'src/a copy.ts')).toEqual({ ok: true, path: 'src/a copy.ts' });
-      expect(control.file('src/a copy.ts')).toBeUndefined();
-      expect(await entries.remove(CWD, 'nope.ts')).toMatchObject({ ok: false, reason: 'missing' });
-      expect(['trash', 'permanent']).toContain(entries.removal(CWD));
-    });
-
-    it.skipIf(!has('entries'))('brings dropped files in under free names', async () => {
-      const { host, control } = await setup();
-      const dropped = [{ file: new File(['dropped'], 'README.md'), entry: null }];
-      const result = await host.entries!.importFiles(CWD, '', dropped);
-      expect(result).toEqual({ ok: true, paths: ['README copy.md'] });
-      expect(control.file('README copy.md')).toBe('dropped');
-      expect(control.file('README.md')).toBe(FILES['README.md']);
-    });
-
-    it.skipIf(!has('search'))('finds the matching lines, 1-based, with their ranges', async () => {
-      const { host } = await setup();
-      const result = await host.search!(CWD, 'answer', { caseSensitive: true, searchId: 'contract' });
-      const a = result.matches.find((m) => m.path === 'src/a.ts' && m.line === 1);
-      expect(a).toMatchObject({ text: 'const answer = 42;', ranges: [{ start: 6, end: 12 }] });
-      expect(result.matches.some((m) => m.path === 'README.md')).toBe(false);
-    });
-
-    it.skipIf(!has('gitStatus'))("reads the folder's git status", async () => {
-      const { host } = await setup();
-      expect(await host.gitStatus!(CWD)).toEqual(STATUS);
-    });
-
-    it.skipIf(!has('workingTreeDiff'))('reads the working tree against HEAD as a patch', async () => {
-      const { host } = await setup();
-      expect(await host.workingTreeDiff!(CWD)).toBe(DIFF);
-    });
-
-    it.skipIf(!has('watch'))('tells watchers the folder may have changed, until they unsubscribe', async () => {
-      const { host, control } = await setup();
-      const seen = vi.fn();
-      const off = host.watch!(SCOPE, seen);
-      control.touch!();
-      expect(seen).toHaveBeenCalledTimes(1);
-      expect(['tool-result', 'git']).toContain(seen.mock.calls[0]![0]);
-      off();
-      control.touch!();
-      expect(seen).toHaveBeenCalledTimes(1);
-    });
-
-    it.skipIf(!has('editorPrefs'))('keeps editor preferences and tells subscribers', async () => {
-      const { host } = await setup();
-      const prefs = host.editorPrefs!;
-      expect(Object.keys(prefs.get()).sort()).toEqual(Object.keys(DEFAULT_EDITOR).sort());
-      const seen = vi.fn();
-      cleanup.push(prefs.subscribe(seen));
-      prefs.set({ tabSize: prefs.get().tabSize === 4 ? 2 : 4 });
-      expect(seen).toHaveBeenCalledTimes(1);
-      prefs.reset();
-      expect(prefs.get()).toEqual(DEFAULT_EDITOR);
-    });
-
-    it.skipIf(!has('system'))('says whether a folder is on this machine', async () => {
-      const { host } = await setup();
-      expect(typeof host.system!.isLocal(CWD)).toBe('boolean');
-    });
-
-    it.skipIf(!has('mediaUrl'))('gives a media file an address', async () => {
-      const { host } = await setup();
-      expect(typeof host.mediaUrl!({ kind: 'file', cwd: CWD, path: 'logo.png', version: 1 })).toBe('string');
-    });
-  });
-}

package/src/files/testing/demo.ts

@@ -1,36 +0,0 @@
-/**
- * A small demo folder for the Files and Diffs tabs: a few sources, a git
- * status and the working-tree patch that matches it.
- */
-import type { FixtureFilesHostOptions } from '../headless/fixture-host';
-
-/** The demo folder's files, its git status and its working-tree patches. */
-export const DEMO_FILES: Required<FixtureFilesHostOptions> = {
-  files: {
-    'README.md': '# Greeter\n\nSays hello.\n',
-    'package.json': '{\n  "name": "greeter",\n  "type": "module"\n}\n',
-    'src/greet.ts': 'export function greet(name: string): string {\n  return `Hello, ${name}!`;\n}\n',
-    'src/index.ts': "import { greet } from './greet';\n\nconsole.log(greet('world'));\n",
-  },
-  status: [{ path: 'src/greet.ts', status: 'modified' }],
-  diff: `diff --git a/src/greet.ts b/src/greet.ts
---- a/src/greet.ts
-+++ b/src/greet.ts
-@@ -1,3 +1,3 @@
- export function greet(name: string): string {
--  return 'Hello, ' + name;
-+  return \`Hello, \${name}!\`;
- }
-`,
-  fileDiffs: {
-    'src/greet.ts': `diff --git a/src/greet.ts b/src/greet.ts
---- a/src/greet.ts
-+++ b/src/greet.ts
-@@ -1,3 +1,3 @@
- export function greet(name: string): string {
--  return 'Hello, ' + name;
-+  return \`Hello, \${name}!\`;
- }
-`,
-  },
-};

package/src/files/testing/index.ts

@@ -1,7 +0,0 @@
-/**
- * `zidane-ui/files/testing`: a `FilesHost` that runs in memory
- * (`createFixtureFilesHost`) and a demo folder (`DEMO_FILES`), for docs,
- * demos, galleries and an app's own tests. Not for production hosts.
- */
-export * from '../headless/fixture-host';
-export * from './demo';