@@ -63,7 +63,7 @@ jobs:
       - name: Install browsers
         uses: ./.github/actions/playwright-install
         with:
-          browsers: chromium firefox webkit
+          browsers: chromium firefox
 
       # Coverage on Chromium (v8 coverage reads Chromium only), failing under each
       # workspace's floor (coverage-floors.json). The kit's component tests use the runner's
@@ -73,10 +73,10 @@ jobs:
         env:
           CHROME: /usr/bin/google-chrome
 
-      - name: Run the browser cache tests on Firefox and WebKit
+      - name: Run the browser cache tests on Firefox
         run: pnpm --filter @nanoforge-dev/editor-project exec vitest run --config vitest.config.ts --project browser
         env:
-          BROWSERS: firefox,webkit
+          BROWSERS: firefox
 
       - name: Upload coverage
         if: always()
 
@@ -3,7 +3,14 @@ import { join } from 'node:path';
 
 const ROOT = join(import.meta.dirname, '../../..');
 const BUILD = join(import.meta.dirname, '../dist/index.js');
-const SOURCES = ['apps/editor/src', 'apps/editor/server', 'packages', 'plugins', 'tooling'];
+const SOURCES = [
+  'apps/editor/src',
+  'apps/editor/server',
+  'apps/editor/tutorial',
+  'packages',
+  'plugins',
+  'tooling',
+];
 const SKIPPED = new Set([
   'node_modules',
   'dist',
 
@@ -253,6 +253,10 @@ if (existsSync(join(pong, 'node_modules/.bin/nf')) && bridge) {
     linkNodeModules(join(pong, 'apps/client/node_modules'), join(tutorial, 'node_modules'));
     rmSync(join(tutorial, 'node_modules/@nanoforge-dev/cli'), { recursive: true, force: true });
     symlinkSync(cli, join(tutorial, 'node_modules/@nanoforge-dev/cli'));
+    /** Builds run the project's own `nf`: without it they need one on the PATH, which CI has not. */
+    mkdirSync(join(tutorial, 'node_modules/.bin'), { recursive: true });
+    rmSync(join(tutorial, 'node_modules/.bin/nf'), { force: true });
+    symlinkSync(join(cli, 'dist/nf.js'), join(tutorial, 'node_modules/.bin/nf'));
     symlinkSync(
       realpathSync(join(pong, 'node_modules/@nanoforge-dev/config')),
       join(tutorial, 'node_modules/@nanoforge-dev/config'),
 
@@ -10,6 +10,7 @@
     ".engine/**"
   ],
   "ignoreDependencies": ["eslint-formatter-pretty", "@nanoforge-dev/actions"],
+  "ignoreBinaries": ["mkfifo"],
   "workspaces": {
     ".": {
       "entry": ["scripts/*.mjs", "vitest.*.ts", "commitlint.config.cjs"]
 
@@ -34,6 +34,19 @@ import { serveEngine } from '../../src/worker-rpc/serve-engine';
 
 const MAIN = 'apps/client/src/main.ts';
 
+/**
+ * Waits for a check's result. A checker runs TypeScript over the project: with coverage on a slow
+ * runner it takes several times longer than locally, so the wait is long and the tests' timeouts
+ * leave room for it.
+ */
+const settled = (done: () => unknown, timeout = 25_000) =>
+  vi.waitFor(
+    () => {
+      if (!done()) throw new Error('not yet');
+    },
+    { timeout, interval: 25 },
+  );
+
 /** Worker plugin: renames the first `const` declared in a file. */
 const renamePlugin: WorkerPluginModule = {
   activate: (sdk) => {
@@ -229,22 +242,18 @@ describe('CodeService', () => {
     await code.engine();
     await (await code.engine()).setFiles([{ path: uri, text: await documents.getText(uri) }]);
     const watch = code.watchDiagnostics(uri);
-    const start = Date.now();
-    while (!diagnostics.forUri(uri).length && Date.now() - start < 8000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri(uri).length);
     expect(diagnostics.forUri(uri).map((d) => d.code)).toEqual([2322]);
     watch.dispose();
     expect(diagnostics.forUri(uri)).toEqual([]);
     code.dispose();
-  });
+  }, 60_000);
 
   it('checks every file of the project while asked to, read-only packages aside', async () => {
     const { code, diagnostics } = setup();
     const uri = 'checks/broken.ts';
     const check = code.checkProject();
-    const start = Date.now();
-    while (!diagnostics.forUri(uri).length && Date.now() - start < 15_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri(uri).length);
     expect(diagnostics.forUri(uri)).toMatchObject([
       { code: 2322, source: 'typescript', line: 1, column: 14 },
     ]);
@@ -254,7 +263,7 @@ describe('CodeService', () => {
     check.dispose();
     expect(diagnostics.forUri(uri)).toEqual([]);
     code.dispose();
-  });
+  }, 60_000);
 
   it('still checks the whole project when an edit comes before the first check ends', async () => {
     const { code, diagnostics } = setup();
@@ -265,42 +274,34 @@ describe('CodeService', () => {
       return [];
     });
     const check = code.checkProject();
-    const start = Date.now();
-    while (!diagnostics.forUri('checks/broken.ts').length && Date.now() - start < 15_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri('checks/broken.ts').length);
     expect(diagnostics.forUri('checks/broken.ts').map((d) => d.code)).toEqual([2322]);
     await project.fs.write('checks/speed.ts', 'export const speed = 1;\n');
     check.dispose();
     code.dispose();
-  }, 20_000);
+  }, 60_000);
 
   it('checks everything again after an edit to global declarations', async () => {
     const { code, diagnostics } = setup();
     const check = code.checkProject();
-    const start = Date.now();
-    while (!diagnostics.forUri('checks/broken.ts').length && Date.now() - start < 15_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri('checks/broken.ts').length);
     const refresh = vi.spyOn(code, 'refreshDiagnostics');
     await project.fs.write(
       'checks/speed.ts',
       'export const speed = 1;\ndeclare global {\n  var debugSpeed: number;\n}\n',
     );
-    const edited = Date.now();
     const checked = () => new Set(refresh.mock.calls.flatMap(([paths]) => paths));
-    while (!checked().has('checks/broken.ts') && Date.now() - edited < 10_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => checked().has('checks/broken.ts'));
     expect(checked().has('checks/broken.ts')).toBe(true);
     await project.fs.write('checks/speed.ts', 'export const speed = 1;\n');
     check.dispose();
     code.dispose();
-  }, 30_000);
+  }, 60_000);
 
   it('keeps an edit made while a check reads what changed', async () => {
     const { code, diagnostics } = setup();
     const check = code.checkProject();
-    const start = Date.now();
-    while (!diagnostics.forUri('checks/broken.ts').length && Date.now() - start < 15_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri('checks/broken.ts').length);
     const refresh = vi.spyOn(code, 'refreshDiagnostics');
     /** While the check of `broken.ts` reads it, `speed.ts` changes: what imports it is checked. */
     const service = code as unknown as {
@@ -313,35 +314,29 @@ describe('CodeService', () => {
     });
     await project.fs.write('checks/broken.ts', 'export const n: number =\n  "other";\n');
     const user = 'checks/uses-speed.ts';
-    const edited = Date.now();
     const checked = () => new Set(refresh.mock.calls.flatMap(([paths]) => paths));
-    while (!checked().has(user) && Date.now() - edited < 10_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => checked().has(user));
     expect(checked().has('checks/broken.ts')).toBe(true);
     expect(checked().has(user)).toBe(true);
     await project.fs.write('checks/broken.ts', 'export const n: number =\n  "text";\n');
     await project.fs.write('checks/speed.ts', 'export const speed = 1;\n');
     check.dispose();
     code.dispose();
-  }, 30_000);
+  }, 60_000);
 
   it('after an edit, checks again only the file and what imports it', async () => {
     const { code, diagnostics } = setup();
     const check = code.checkProject();
-    const start = Date.now();
-    while (!diagnostics.forUri('checks/broken.ts').length && Date.now() - start < 15_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri('checks/broken.ts').length);
     const refresh = vi.spyOn(code, 'refreshDiagnostics');
     await project.fs.write('checks/speed.ts', 'export const speed = "fast";\n');
     const user = 'checks/uses-speed.ts';
-    const edited = Date.now();
-    while (!diagnostics.forUri(user).length && Date.now() - edited < 10_000)
-      await new Promise((r) => setTimeout(r, 25));
+    await settled(() => diagnostics.forUri(user).length);
     expect(diagnostics.forUri(user).map((d) => d.code)).toEqual([2322]);
     const checked = new Set(refresh.mock.calls.flatMap(([paths]) => paths));
     expect([...checked].sort()).toEqual(['checks/speed.ts', user]);
     await project.fs.write('checks/speed.ts', 'export const speed = 1;\n');
     check.dispose();
     code.dispose();
-  });
+  }, 60_000);
 });
@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { EditorAction, ResolvedKeybinding } from '@nanoforge-dev/editor-sdk/ui';
+
+import {
+  conflictsOf,
+  filterRows,
+  keymapRows,
+  strokesOf,
+  userConflicts,
+} from '../../src/keymap/keymap-rows';
+
+vi.mock('@nanoforge-dev/editor-sdk/ui', () => ({
+  actionId: (command: string, args: readonly unknown[]) =>
+    args.length ? `${command}:${JSON.stringify(args)}` : command,
+  actionLabel: (action: { title: string; category?: string }) =>
+    action.category ? `${action.category}: ${action.title}` : action.title,
+  bindingsConflict: (a: ResolvedKeybinding, b: ResolvedKeybinding) =>
+    a.key === b.key && a.command !== b.command,
+  findConflicts: (bindings: readonly ResolvedKeybinding[]) =>
+    [...Map.groupBy(bindings, (binding) => binding.key).values()]
+      .filter((group) => group.length > 1)
+      .map((group) => ({ bindings: group })),
+  formatKeybinding: (key: string) => key.replace('Mod', 'Ctrl'),
+  isActionChanged: (overrides: readonly { command: string }[], command: string) =>
+    overrides.some((override) => override.command === command),
+  parseKeybinding: (key: string) => {
+    if (!key.trim()) throw new Error('empty');
+    return key.split(' ');
+  },
+}));
+
+const action = (command: string, title: string, category?: string): EditorAction => ({
+  id: command,
+  command,
+  args: [],
+  title,
+  ...(category && { category }),
+  when: [],
+});
+
+const binding = (
+  command: string,
+  key: string,
+  source: ResolvedKeybinding['source'] = 'default',
+): ResolvedKeybinding => ({ command, args: [], key, strokes: key.split(' '), source });
+
+const SAVE = action('file.save', 'Save', 'File');
+const PLAY = action('run.play', 'Play', 'Run');
+const BINDINGS = [binding('file.save', 'Mod+S'), binding('editor.hidden', 'Mod+H')];
+const LAYERS = { before: [], own: [{ command: 'run.play' }], after: [] } as never;
+
+describe('keymap rows', () => {
+  it('lists every action, and the untitled commands that have shortcuts', () => {
+    const rows = keymapRows([SAVE, PLAY], LAYERS, BINDINGS, new Set());
+    expect(rows.map((row) => [row.label, row.bindings.length, row.changed])).toEqual([
+      ['File: Save', 1, false],
+      ['Run: Play', 0, true],
+      ['editor.hidden', 1, false],
+    ]);
+  });
+
+  it('marks the actions whose shortcuts conflict with a change of the user', () => {
+    const mine = binding('run.play', 'Mod+S', 'user');
+    const bindings = [...BINDINGS, mine];
+    const conflicting = userConflicts(bindings);
+    expect(conflicting).toEqual(new Set([BINDINGS[0], mine]));
+    expect(userConflicts(BINDINGS)).toEqual(new Set());
+    const rows = keymapRows([SAVE, PLAY], LAYERS, bindings, conflicting);
+    expect(rows.filter((row) => row.conflict).map((row) => row.action.id)).toEqual([
+      'file.save',
+      'run.play',
+    ]);
+  });
+
+  it('filters by label, command, shortcut, changes and conflicts', () => {
+    const rows = keymapRows([SAVE, PLAY], LAYERS, BINDINGS, new Set([BINDINGS[0]!]));
+    const ids = (query: string, onlyChanged = false, onlyConflicts = false) =>
+      filterRows(rows, { query, onlyChanged, onlyConflicts }).map((row) => row.action.id);
+    expect(ids('  SAVE ')).toEqual(['file.save']);
+    expect(ids('run.')).toEqual(['run.play']);
+    expect(ids('ctrl+h')).toEqual(['editor.hidden']);
+    expect(ids('mod+s')).toEqual(['file.save']);
+    expect(ids('', true)).toEqual(['run.play']);
+    expect(ids('', false, true)).toEqual(['file.save']);
+    expect(ids('nothing')).toEqual([]);
+  });
+
+  it('parses strokes, and finds what a candidate shortcut would get in the way of', () => {
+    expect(strokesOf('Mod+K S')).toEqual(['Mod+K', 'S']);
+    expect(strokesOf(' ')).toBeUndefined();
+    expect(conflictsOf(BINDINGS, PLAY, 'Mod+S', undefined)).toEqual([BINDINGS[0]]);
+    expect(conflictsOf(BINDINGS, PLAY, 'Mod+S', 'editorFocus', BINDINGS[0])).toEqual([]);
+    expect(conflictsOf(BINDINGS, PLAY, ' ', undefined)).toEqual([]);
+  });
+});