Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

117 KB
Raw Blame
import { affectsBuild } from '../shared/editable';
import { DEFAULT_SETTINGS, type SettingsPatch, type SettingsResult, type SettingsState } from '../shared/settings';
import type { AgentInfo, AnimEntry, BuildStatus, CadQueryImportResult, DrawingEntry, DrawingList, ExportResult, FileNode, ImportResult, MeshExportOptions, ModelMap, PartMap, PreviewResult, ProjectInfo, ProjectListEntry, ResultEntry, SaveState, UpdateInfo } from '../shared/types';
import { AnalysisPanel } from './analysispanel';
import { AnimPanel, animKey, videoKey } from './animpanel';
import { SOMA_VERSION } from '../shared/version';
import { CodePanel, codeRows, isDxf, isPdf, type Mark } from './code';
import { DRAWINGS_KEY, DrawingsView } from './drawings';
import { DrawingLink } from './drawlink';
import { AnimTool } from './animtool';
import { Busy } from './busy';
import { DRAG_FILE, FileTree, IMAGE_EXT, TEXT_EXT, VIDEO_EXT } from './filetree';
import { FileView } from './fileview';
import { hydrateIcons, icon } from './icons';
import { Markup } from './markup';
import { MAX_QUOTE } from './pdfview';
import { MeasureTool } from './measuretool';
import { SectionTool } from './sectiontool';
import { ExplodeTool } from './explodetool';
import { HelpDialog } from './help';
import { SettingsDialog } from './settings';
import { AboutPage, ShortcutsPage, StoragePage, ViewerPage } from './settingspages';
import { SkillsPanel } from './skills';
import { ParamsPanel } from './params';
import { StructureTree } from './tree';
import { Tour, tourSteps, type TourContext } from './tutorial';
import { ResultTool } from './resulttool';
import { ResultLayer } from './resultview';
import { TerminalTabs } from './terminals';
import { $, ask, el, fmtWhen, menuItem, menus, toast } from './ui';
import { VersionsBar } from './versions';
import { VideoView } from './videoview';
import { PickResult, Viewer, ViewName } from './viewer';

hydrateIcons();
const api = window.soma;

/** Ladebildschirm aus index.html ausblenden. Auch bei einem Fehler im Aufbau, sonst bliebe er für immer stehen. */
function hideBoot(): void {
  const boot = document.getElementById('boot');
  if (!boot || boot.classList.contains('gone')) return;
  boot.classList.add('gone');
  setTimeout(() => boot.remove(), 200);
}
window.addEventListener('error', hideBoot, { once: true });

/**
 * Ohne WebGL gibt es keine 3D-Ansicht, und die ganze Oberfläche hängt am Viewer. Unter Linux startet der Hauptprozess dann
 * mit Software-Rendering neu (main/main.ts), sonst klar sagen, was fehlt, statt mit leerem Fenster stehen zu bleiben.
 */
function createViewer(): Viewer {
  try {
    return new Viewer($('viewer'));
  } catch (e) {
    const title = el('h1', {}, '3D view unavailable');
    const text = el('p', {}, 'SOMA needs WebGL 2 for the 3D view, but this system could not provide it. Install or update the graphics driver, or start SOMA on a machine with graphics acceleration.');
    document.body.replaceChildren(el('div', { className: 'fatal' }, title, text, el('pre', {}, String(e instanceof Error ? e.message : e))));
    void window.soma.gpu.webglFailed().then((restarting) => {
      if (!restarting) return;
      title.textContent = 'Restarting with software rendering';
      text.textContent = 'No graphics acceleration is available, so SOMA restarts and draws the 3D view in software. This is slower for large models. If no window appears, start SOMA again.';
    }).catch(() => { /* Meldung bleibt */ });
    throw e;
  }
}
const viewer = createViewer();
viewer.attachCube($('cube-view'));
const terminals = new TerminalTabs($('term-tabs'), $('term-panes'), $('btn-term-add'), $('strip-tabs'));

let project: ProjectInfo | null = null;
let saveState: SaveState | null = null;
let buildStatus: BuildStatus = { state: 'idle' };
let lastOkAt: number | null = null;
let errorAt = 0;
let map: ModelMap | null = null;
let loadSeq = 0;
let selection: { partId: string; pick: PickResult | null } | null = null;
/** Alle ausgewählten Bauteile (Strg/Shift-Klick, Rahmen, Baum). `selection` ist das zuletzt gewählte darunter. */
let picked: string[] = [];
let agents: AgentInfo[] = [];
const textCache = new Map<string, string>();

const store = {
  get: (k: string) => { try { return localStorage.getItem(k); } catch { return null; } },
  set: (k: string, v: string) => { try { localStorage.setItem(k, v); } catch { /* ohne Speicher geht es auch */ } },
};

async function readText(rel: string): Promise<string> {
  let t = textCache.get(rel);
  if (t === undefined) { t = await api.fs.readText(rel); textCache.set(rel, t); }
  return t;
}

const num = (v: number, digits = 1) => v.toLocaleString('en-US', { maximumFractionDigits: digits });
const SURFACE: Record<string, string> = {
  PLANE: 'plane', CYLINDER: 'cylinder', CONE: 'cone', SPHERE: 'sphere', TORUS: 'torus', BSPLINE: 'freeform', BEZIER: 'freeform',
  REVOLUTION: 'surface of revolution', EXTRUSION: 'extruded surface', OFFSET: 'offset surface', OTHER: 'other',
};
const surfaceName = (s: string | null) => (s ? SURFACE[s] ?? s.toLowerCase() : 'face');
const ERROR_KIND: Record<string, string> = { Timeout: 'Time limit exceeded', PythonStart: 'Python could not be started', NoResult: 'Build without result' };

// ---- Seitenleiste (Parameter, Dateien, Analyse, Animation, Skills, E82) und Code-Spalte (Entwurf 2) ------------------

type PanelName = 'params' | 'files' | 'analysis' | 'anim' | 'skills';
const PANELS: PanelName[] = ['params', 'files', 'analysis', 'anim', 'skills'];
let panel: PanelName | null = null;
/** Zuletzt gezeigte Ansicht der Seitenleiste: Der Schalter oben bringt sie wieder. */
let lastPanel: PanelName = 'files';
let filesDirty = true;
let codeOpen = false;
/** Der Dateibaum entsteht nach dem Code-Panel, das ihm schon beim Aufbau die offene Datei meldet. */
let fileTree: FileTree | null = null;

function showPanel(p: PanelName | null): void {
  panel = p;
  if (p) lastPanel = p;
  $('side').hidden = !p;
  $('split-side').hidden = !p;
  $('panel-params').hidden = p !== 'params';
  $('panel-files').hidden = p !== 'files';
  $('panel-analysis').hidden = p !== 'analysis';
  $('panel-anim').hidden = p !== 'anim';
  $('panel-skills').hidden = p !== 'skills';
  // Bericht und Ablauf brauchen mehr Breite als Listen (Entwurf: 352 px). Zieht der Nutzer breiter, gilt seine Breite
  $('side').classList.toggle('wide', p === 'analysis' || p === 'anim');
  document.querySelectorAll<HTMLButtonElement>('#rail [data-panel]').forEach((b) => b.setAttribute('aria-pressed', String(b.dataset.panel === p)));
  if (p === 'files' && filesDirty) void refreshFiles();
  if (p === 'params') void paramsPanel.refresh();
  if (p === 'skills') void skills.refresh();
  else skills.closeDetail();
  if (p === 'analysis') void openResults();
  if (p === 'anim') void openAnims();
  // Nur die Ansichten zum Arbeiten am Modell bleiben über einen Neustart: Ein Ergebnis zeigt sich erst auf Wunsch
  if (p !== 'analysis' && p !== 'anim') store.set('soma.side', p ?? '');
  renderLayout();
  renderResults();
}

/** Code als eigene Spalte neben der Seitenleiste, damit Dateien und Code gleichzeitig offen sein können. */
function showCode(on: boolean): void {
  codeOpen = on;
  $('editor').hidden = !on;
  $('split-code').hidden = !on;
  // Leer aufgemacht: die Stelle der Auswahl zeigen, sonst model.py
  if (on && !code.activeFile) {
    const e = selection ? partEntry(selection.partId) : undefined;
    if (e?.file && e.line) void code.open(e.file, { ...lineRange(e), label: e.name, color: partInfo(e.id)?.color });
    else if (project) void code.open(project.entry);
  }
  renderLayout();
  renderDrawingsRail();
}

/** Spalten-Schalter oben rechts: zeigen, welche Spalten offen sind. */
function renderLayout(): void {
  $('btn-lay-side').setAttribute('aria-pressed', String(!!panel));
  $('btn-lay-code').setAttribute('aria-pressed', String(codeOpen));
  $('btn-lay-agent').setAttribute('aria-pressed', String(!$('terminals').classList.contains('collapsed')));
}

const code = new CodePanel(
  { tabs: $('code-tabs'), info: $('code-info'), banner: $('code-banner'), view: $('code-view'), link: $<HTMLButtonElement>('btn-codelink'), mode: $('code-mode') },
  {
    read: (rel) => api.fs.readText(rel), readBinary: (rel) => api.fs.readBinary(rel), projectId: () => project?.id ?? null, toast, ask: (o) => api.dialog.choose(o),
    changed: () => { if (saveState) renderSaveState(saveState); },
    // Später: Der erste Aufruf kommt schon aus dem Konstruktor, bevor `code` steht
    active: (f) => { fileTree?.setActive(f); queueMicrotask(renderDrawingsRail); },
    saveAndBuild: () => void saveCode(),
    build: () => void api.build.run(),
    link: (href) => openLink(href),
    image: async (rel) => { try { return await imageUrl(rel); } catch { return null; } },
    quote: (file, pages, text) => {
      // Eine Zeile mit Datei und Seite, wie Auswahl und Markierung. Sehr lange Zitate werden gekürzt, das steht in der Meldung.
      const cut = text.length > MAX_QUOTE;
      insertToAgent(`[Quote: ${file} p. ${pages}: "${cut ? `${text.slice(0, MAX_QUOTE)} …` : text}"] `, cut ? `Quote shortened to ${MAX_QUOTE} characters.` : undefined);
    },
    markPage: (file, page, canvas) => void markSource(`${file} p. ${page}`, canvas, canvas.width, canvas.height),
    dxf: (rel, known) => api.dxf.view(rel, known),
    markDxf: (label, canvas) => void markSource(label, canvas, canvas.width, canvas.height),
  },
);

/** Bilddatei aus dem Projekt als blob:-Adresse (die CSP erlaubt blob:). Freigeben muss der Aufrufer. */
async function imageUrl(rel: string): Promise<string> {
  const data = await api.fs.readBinary(rel);
  return URL.createObjectURL(new Blob([data], { type: /\.svg$/i.test(rel) ? 'image/svg+xml' : '' }));
}

/** Link aus einer Markdown-Ansicht: Web-Adressen im Browser, Dateien im Projekt wie ein Klick im Dateibaum. */
function openLink(href: string): void {
  if (/^(https?:|mailto:)/i.test(href)) {
    void api.openUrl(href).then((r) => { if (!r.ok) toast(r.error ?? `${href} could not be opened.`, 'error'); });
    return;
  }
  if (/^[a-z][a-z0-9+.-]*:/i.test(href)) { toast(`For security reasons, this link is not opened: ${href.slice(0, 100)}`, 'error'); return; }
  if (TEXT_EXT.test(href.split('/').pop() ?? '') || isPdf(href) || isDxf(href)) void openCode(href);
  else void openExternal(href);
}

async function openCode(file: string, mark?: Mark): Promise<void> {
  if (!codeOpen) { codeOpen = true; $('editor').hidden = false; $('split-code').hidden = false; renderLayout(); }
  await code.open(file, mark);
}

const skills = new SkillsPanel({ list: $('skills-list'), sum: $('skills-sum'), detail: $('skill-detail'), menu: $('menu-ctx') }, {
  list: () => api.skills.list(),
  set: (id, mode) => api.skills.set(id, mode),
  configure: (id, values) => api.skills.configure(id, values),
  setDefault: (id, mode) => api.skills.setDefault(id, mode),
  open: (file) => void openCode(file),
  edit: (id) => void settings.open(id),
  insert: (text) => insertToAgent(text),
  toast,
  changed: () => { filesDirty = true; textCache.clear(); void refreshSaveState(); void code.refresh(); },
});

// ---- Einstellungen (E78, E81) ---------------------------------------------------------------------------------------

/** Einstellungen der App aus settings.json. Bis sie geladen sind, gelten die Vorgaben. */
let appSettings: SettingsState = { settings: DEFAULT_SETTINGS };

/** Viewer und Messen nach den Einstellungen (sofort, auch bei offenem Modell). */
function applySettings(): void {
  const v = appSettings.settings.viewer;
  viewer.setNavigation(v.navigation, v.invertZoom);
  viewer.setProjection(v.projection);
  measureTool.setDecimals(v.decimals);
}

/** Darstellung beim Öffnen eines Modells (Menü „Display“). Danach gilt bis zum nächsten Modell, was der Nutzer dort umstellt. */
function applyDisplayDefaults(): void {
  const v = appSettings.settings.viewer;
  const want: Record<string, boolean> = { edges: v.edges, wire: v.wireframe, ghost: v.transparent, axes: v.axes };
  document.querySelectorAll<HTMLButtonElement>('[data-display]').forEach((b) => b.setAttribute('aria-checked', String(want[b.dataset.display!])));
  viewer.setEdges(v.edges);
  viewer.setWireframe(v.wireframe);
  viewer.setGhost(v.transparent);
  setAxes(v.axes);
}

/** Ursprung und Achsen: eigener Knopf neben dem ViewCube und Eintrag im Menü „Display“, beide zeigen denselben Stand. */
function setAxes(on: boolean): void {
  $('btn-axes').setAttribute('aria-pressed', String(on));
  document.querySelector('[data-display="axes"]')?.setAttribute('aria-checked', String(on));
  viewer.setAxes(on);
}

async function changeSettings(patch: SettingsPatch): Promise<SettingsResult> {
  const r = await api.settings.set(patch);
  appSettings = { settings: r.settings, ...(r.problem ? { problem: r.problem } : {}) };
  if (r.ok) applySettings();
  return r;
}

const viewerPage = new ViewerPage($('st-viewer'), { current: () => appSettings, set: (patch) => changeSettings(patch), toast });
const storagePage = new StoragePage($('st-storage'), { api: api.storage, toast });
const shortcutsPage = new ShortcutsPage($('st-keys'), { current: () => appSettings });
const aboutPage = new AboutPage($('st-about'), {
  api: api.about, toast,
  openUrl: (url) => void api.openUrl(url).then((r) => { if (!r.ok) toast(r.error ?? `${url} could not be opened.`, 'error'); }),
  openFolder: (area) => void api.storage.open(area).then((r) => { if (!r.ok) toast(`The folder could not be opened: ${r.error ?? 'unknown error'}`, 'error'); }),
  updateCheck: () => appSettings.settings.start.updateCheck,
  setUpdateCheck: async (on) => { const r = await changeSettings({ start: { updateCheck: on } }); if (!$('start').hidden) void renderUpdate(); return r; },
});

// Einstellungen (E78, E81): Reiter Viewer, Skills, Speicher und Info, auch von der Startseite aus. Änderungen an den
// Skills zeigt das Panel „Skills“ sofort
const settings = new SettingsDialog({
  root: $('settings'), nav: $('st-nav'), list: $('st-list'), editor: $('st-editor'), popover: $('menu-skill-name'), newBtn: $('btn-st-new'), importBtn: $('btn-st-import'),
  // Gesperrt wird, was dahinter liegt. Nicht #app: Es umschließt auch Menüs, Meldungen und die Einstellungen selbst
  folderBtn: $('btn-st-folder'), close: $('btn-st-close'), background: [$('topbar'), $('body'), $('start')],
}, {
  library: api.library,
  choose: (o) => api.dialog.choose(o),
  toast,
  link: (href) => {
    if (/^(https?:|mailto:)/i.test(href)) void api.openUrl(href).then((r) => { if (!r.ok) toast(r.error ?? `${href} could not be opened.`, 'error'); });
    else toast('Only web links open from the preview of a skill.', 'info');
  },
  changed: () => { if (project && skills.isLoaded) void skills.refresh(); },
  modelMode: async (id) => (project ? (await api.skills.list()).find((s) => s.id === id)?.mode ?? 'off' : null),
  pages: { viewer: viewerPage, keys: shortcutsPage, storage: storagePage, about: aboutPage },
});
// Hilfe (E83): Knopf in der Leiste und auf der Startseite, F1 überall außer in den Einstellungen
const help = new HelpDialog({ root: $('help'), nav: $('help-nav'), body: $('help-body'), close: $('btn-help-close') as HTMLButtonElement, background: [$('topbar'), $('body'), $('start')] }, {
  help: api.help,
  openUrl: (href) => void api.openUrl(href).then((r) => { if (!r.ok) toast(r.error ?? `${href} could not be opened.`, 'error'); }),
});
$('btn-help').addEventListener('click', () => void help.open());
$('btn-start-help').addEventListener('click', () => void help.open());
window.addEventListener('keydown', (e) => {
  if (e.key !== 'F1' || e.ctrlKey || e.altKey || e.metaKey || settings.isOpen) return;
  e.preventDefault();
  if (help.isOpen) help.close(); else void help.open();
});
$('btn-settings').addEventListener('click', () => void settings.open());
$('btn-start-settings').addEventListener('click', () => void settings.open());
$('btn-skills-manage').addEventListener('click', () => void settings.open());

const paramsPanel = new ParamsPanel({ list: $('params-list'), foot: $('params-foot'), count: $('params-count') }, {
  state: () => api.params.state(),
  set: (values) => api.params.set(values),
  resetAll: () => api.params.resetAll(),
  openCode: (file, line, label) => void openCode(file, { from: line, to: line, label }),
  insert: (text) => insertToAgent(text),
  toast,
});

const files = new FileTree($('tab-files'), $('menu-ctx'), {
  open: (n) => {
    if (TEXT_EXT.test(n.name) || isPdf(n.name) || isDxf(n.name)) void openCode(n.path);
    // Bilder (etwa Markierungen und Skizzen) öffnen auf der Zeichenfläche (E52), das Bildprogramm gibt es per Rechtsklick
    else if (IMAGE_EXT.test(n.name)) void markImage(n.path);
    else if (VIDEO_EXT.test(n.name)) void videoView.open(n.path);
    // STEP- und Netzdateien des Projekts im Viewer, schreibgeschützt wie die Vorschau eines alten Stands
    else if (/\.(step|stp|stl|3mf|amf|obj)$/i.test(n.name)) void fileView.open(n.path);
    else toast('The app has no view for this file type. Right-click: “Open with default app”.', 'info');
  },
  create: async (parent, name, dir) => {
    const r = await api.fs.create(parent, name, dir);
    if (!r.ok || !r.path) { toast(r.error ?? `${name} could not be created.`, 'error'); return false; }
    await refreshFiles();
    if (!dir && TEXT_EXT.test(name)) void openCode(r.path);
    return true;
  },
  rename: async (rel, name) => {
    if (!fileOpAllowed(rel, 'rename')) return true;
    const wasOpen = code.openUnder(rel);
    const playing = videoView.current;
    const r = await api.fs.rename(rel, name);
    if (!r.ok || !r.path) { toast(r.error ?? `${rel} could not be renamed.`, 'error'); return false; }
    // Reiter wandern mit: der alte zu, die Datei unter neuem Namen wieder auf (ohne das Panel zu wechseln)
    code.forget(rel);
    for (const f of wasOpen) void code.open(r.path + f.slice(rel.length), undefined, false);
    // Das laufende Video ebenso, sonst zeigte der Player einen Namen, den es nicht mehr gibt
    if (playing && isUnder(playing, rel)) void videoView.open(r.path + playing.slice(rel.length));
    await refreshFiles();
    return true;
  },
  trash: (rel) => void (async () => {
    if (!fileOpAllowed(rel, 'delete')) return;
    const r = await api.fs.trash(rel);
    if (r.canceled) return;
    if (!r.ok) { toast(r.error ?? `${rel} could not be deleted.`, 'error'); return; }
    code.forget(rel);
    if (videoView.current && isUnder(videoView.current, rel)) videoView.close();
    await refreshFiles();
    toast(`${rel} is in the Recycle Bin.`);
  })(),
  reveal: (rel) => void api.fs.reveal(rel).then((r) => { if (!r.ok) toast(r.error ?? 'Explorer could not be opened.', 'error'); }),
  openExternal: (rel) => void openExternal(rel),
  mark: (rel) => void markImage(rel),
  toAgent: (rel) => insertToAgent(`[File: ${rel}] `),
  copyPath: (rel) => void navigator.clipboard.writeText(rel).then(() => toast(`Path copied: ${rel}`), (e) => toast(`The path could not be copied: ${e instanceof Error ? e.message : String(e)}`, 'error')),
  showInTree: (rel, rename) => void showInTree(rel, rename),
});
fileTree = files;
files.attachSearch($<HTMLInputElement>('files-filter'));

const isUnder = (rel: string, dir: string) => rel === dir || rel.startsWith(`${dir}/`);

/** Aus einem anderen Panel (Videos im Reiter Animation): Dateibaum zeigen, die Datei darin finden, auf Wunsch umbenennen. */
async function showInTree(rel: string, rename: boolean): Promise<void> {
  showPanel('files');
  await refreshFiles();
  files.reveal(rel, !rename);
  if (rename) files.startRenameAt(rel);
}
files.setActive(code.activeFile);

async function openExternal(rel: string): Promise<void> {
  const r = await api.fs.openExternal(rel);
  if (!r.ok) toast(r.error ?? `${rel} could not be opened.`, 'error');
}

/** Umbenennen und Löschen nur ohne ungespeicherte Eingaben im Editor, sonst gingen sie unter dem alten Namen verloren. */
function fileOpAllowed(rel: string, what: 'rename' | 'delete'): boolean {
  const open = code.unsaved().filter((f) => f === rel || f.startsWith(`${rel}/`));
  if (!open.length) return true;
  toast(`To ${what}, first save or discard the changes: ${open.join(', ')}`, 'error');
  return false;
}

async function refreshFiles(): Promise<void> {
  // Ohne Modell (Startseite) gibt es keine Dateien: Die Anfrage scheiterte nur und stand als Fehler im Protokoll
  if (panel !== 'files' || !project) { filesDirty = true; return; }
  filesDirty = false;
  try { files.render(await api.fs.list()); } catch { /* Projekt wechselt gerade */ }
}

$('btn-file-new').addEventListener('click', () => files.startCreate('', false));
$('btn-folder-new').addEventListener('click', () => files.startCreate('', true));

// Dateien und Ordner ziehen: überall im Fenster ablegen landet in inputs/. Ohne das würde Electron die Datei als Seite öffnen.
// Bauteile und Dateien aus der App lassen sich ins Terminal ziehen (ersetzt die Übergabeleiste, Entwurf 2).
let dragDepth = 0;
const hasFiles = (e: DragEvent) => !!e.dataTransfer && [...e.dataTransfer.types].includes('Files');
const isInternal = (e: DragEvent) => !!e.dataTransfer && [...e.dataTransfer.types].some((t) => t === DRAG_FILE);
const overTerminal = (e: DragEvent) => !!(e.target as HTMLElement | null)?.closest?.('#term-panes');
document.addEventListener('dragenter', (e) => {
  if (!hasFiles(e)) return;
  if (dragDepth++ === 0) { document.body.classList.add('dragging'); if (project) showPanel('files'); }
});
document.addEventListener('dragleave', (e) => { if (hasFiles(e) && --dragDepth <= 0) { dragDepth = 0; document.body.classList.remove('dragging'); } });
document.addEventListener('dragover', (e) => {
  e.preventDefault();
  const term = isInternal(e) && overTerminal(e);
  $('term-panes').classList.toggle('dropping', term);
  if (e.dataTransfer) e.dataTransfer.dropEffect = (hasFiles(e) && project) || term ? 'copy' : 'none';
});
document.addEventListener('dragend', () => $('term-panes').classList.remove('dropping'));
document.addEventListener('drop', (e) => {
  e.preventDefault();
  dragDepth = 0;
  document.body.classList.remove('dragging');
  $('term-panes').classList.remove('dropping');
  if (isInternal(e)) {
    if (!overTerminal(e)) return;
    const rel = e.dataTransfer?.getData(DRAG_FILE);
    if (rel) insertToAgent(`[File: ${rel}] `);
    return;
  }
  const list = [...(e.dataTransfer?.files ?? [])];
  if (list.length && project) void importFiles(list);
});

async function importFiles(list: File[]): Promise<void> {
  reportImport(await api.fs.importFiles(list));
}

// Knopf „Import“: derselbe Weg wie Ziehen, nur mit Dateidialog. Zeigt Nutzern, wie Daten ins Modell kommen
$('btn-import').addEventListener('click', async () => {
  if (!project) return;
  const r = await api.fs.importPick();
  if (r) reportImport(r);
});

function reportImport(r: ImportResult): void {
  showPanel('files');
  const lines: string[] = [];
  if (r.files.length) lines.push(`Added to inputs/: ${r.files.map((f) => f.replace(/^inputs\//, '')).join(', ')}`, 'The agent can now use them in the script.');
  // Ein Ordner voller Verknüpfungen soll die Meldung nicht über den Bildschirm ziehen
  const shown = r.errors.slice(0, 8);
  if (r.errors.length > shown.length) shown.push(`… and ${r.errors.length - shown.length} more`);
  if (r.errors.length) lines.push(`Not added:\n${shown.join('\n')}`);
  if (lines.length) toast(lines.join('\n'), r.errors.length ? 'error' : 'ok');
}

// ---- Bauteile und Auswahl ---------------------------------------------------------------------------------------

// Strukturbaum oben links im Viewer (E82). Ausblenden und Transparent liegen im Viewer und gelten für Modell, Analyse und Animation
const tree = new StructureTree($('tree'), {
  select: (s) => {
    if (s.how === 'replace') selectPart(s.id, null, true);
    else if (s.how === 'range') setPicked(s.ids, s.id);
    else setPicked(picked.includes(s.id) ? picked.filter((x) => x !== s.id) : [...picked, s.id], picked.includes(s.id) ? picked.filter((x) => x !== s.id).at(-1) ?? null : s.id);
  },
  setVisible: (ids, on) => { viewer.setVisible(ids, on); resultTool.forgetProbe(); },
  isVisible: (id) => viewer.isVisible(id),
  setGhost: (ids, on) => { viewer.setGhosted(ids, on); resultTool.forgetProbe(); },
  isGhost: (id) => viewer.isGhosted(id),
  showAll: () => { viewer.showAll(); resultTool.forgetProbe(); },
  context: (id, x, y) => openPartMenu(id, x, y),
  groupContext: (ids, name, x, y) => openGroupMenu(ids, name, x, y),
  resized: () => fitDock(),
});

const refreshTree = () => { tree.set(viewer.partList(), picked); resultTool.forgetProbe(); fitDock(); };

/**
 * Werkzeuge oben in der Mitte neben dem Baum: Der Platz links gehört dem Baum, wird es eng, zeigen sie nur Symbole (E82).
 * Gemessen statt per CSS, weil die Breite des Baums vom Namen des Modells und vom Aufklappen abhängt.
 */
function fitDock(): void {
  const dock = $('dock'), vtop = $('vtop');
  $('tree-space').style.width = `${$('tree').offsetWidth}px`;
  dock.classList.remove('compact');
  const room = vtop.clientWidth - $('tree-space').offsetWidth - $('vtop').querySelector<HTMLElement>('.cubespace')!.offsetWidth - 3 * 12;
  dock.classList.toggle('compact', dock.scrollWidth > room);
}
new ResizeObserver(() => fitDock()).observe($('viewer'));
// Höhe des sichtbaren Banners (Vorschau, Dateiansicht): Die Karten unten links rücken darüber, sonst verdeckt es sie
const bannerObserver = new ResizeObserver(() => {
  const h = Math.max($('preview-banner').offsetHeight, $('file-banner').offsetHeight);
  if (h) $('viewer').style.setProperty('--bn-h', `${h}px`);
});
bannerObserver.observe($('preview-banner'));
bannerObserver.observe($('file-banner'));
const partEntry = (id: string): PartMap | undefined => map?.parts.find((x) => x.id === id);
const partInfo = (id: string) => viewer.partList().find((x) => x.id === id);
const lineRange = (e: PartMap) => ({ from: e.line!, to: e.end_line && e.end_line >= e.line! ? e.end_line : e.line! });

function selectPart(id: string | null, pick: PickResult | null, focus = false): void {
  selection = id ? { partId: id, pick } : null;
  picked = id ? [id] : [];
  if (!pick) viewer.select(id); // ein Klick im Viewer hat die Auswahl dort schon gesetzt
  if (id && focus) viewer.focusPart(id);
  tree.select(picked);
  void renderSelection();
}

/** Mehrere Bauteile auswählen, `primary` zeigt die Auswahlkarte (bei mehreren eine Zusammenfassung). */
function setPicked(ids: string[], primary: string | null, pick: PickResult | null = null): void {
  picked = [...new Set(ids)];
  const main = primary && picked.includes(primary) ? primary : picked.at(-1) ?? null;
  selection = main ? { partId: main, pick: main === primary ? pick : null } : null;
  viewer.setSelection(picked, main);
  tree.select(picked);
  void renderSelection();
}

// Klick ins Modell: allein auswählen, mit Shift dazu, mit Strg dazu oder heraus. Daneben geklickt mit Taste: Auswahl bleibt
viewer.onPick = (r, mods) => {
  const add = mods.shift || mods.ctrl;
  if (!add) { selectPart(r?.partId ?? null, r); return; }
  if (!r) { setPicked(picked, selection?.partId ?? null, selection?.pick ?? null); return; }
  if (mods.ctrl && picked.includes(r.partId)) { const rest = picked.filter((x) => x !== r.partId); setPicked(rest, rest.at(-1) ?? null); return; }
  setPicked([...picked, r.partId], r.partId, r);
};
// Alt + links ziehen: Rahmenauswahl, mit Shift oder Strg dazu
viewer.onBox = (ids, add) => setPicked(add ? [...picked, ...ids] : ids, ids.at(-1) ?? (add ? selection?.partId ?? null : null));
viewer.onContext = (id, x, y) => { if (id) openPartMenu(id, x, y); else openViewerMenu(x, y); };

const partName = (id: string) => partEntry(id)?.name ?? partInfo(id)?.name ?? id;

async function renderSelection(): Promise<void> {
  const card = $('selcard');
  if (!selection) { card.hidden = true; return; }
  $<HTMLButtonElement>('btn-sel-export').disabled = picked.length > 1;
  if (picked.length > 1) {
    // Mehrere: Zahl und Namen, kein Code und kein Export eines einzelnen Teils
    $('sel-name').textContent = `${picked.length} parts selected`;
    $('sel-name').title = '';
    $('sel-swatch').style.background = 'var(--acc)';
    const names = picked.map(partName);
    $('info').textContent = names.slice(0, 6).join(', ') + (names.length > 6 ? ` and ${names.length - 6} more` : '');
    $('code').replaceChildren();
    $<HTMLButtonElement>('btn-sel-code').disabled = true;
    card.hidden = false;
    return;
  }
  const { partId, pick } = selection;
  const p = partInfo(partId);
  const e = partEntry(partId);
  const name = e?.name ?? p?.name ?? partId;
  // Zukaufteile (Normteile aus soma.fasteners, E48) sehen aus wie eigene Teile, der Zusatz unterscheidet sie
  $('sel-name').textContent = name + (p?.role === 'reference' ? ' (reference)' : p?.role === 'hardware' ? ' (purchased part)' : '');
  $('sel-name').title = p?.group ? `Group ${p.group}` : '';
  $('sel-swatch').style.background = p?.color ?? '';
  const bits = pick?.faceId != null
    ? ['Face', surfaceName(pick.surface), ...(pick.area != null ? [`${num(pick.area)} mm²`] : [])]
    : pick?.cut ? ['Cut face', 'whole part'] : ['whole part'];
  $('info').textContent = bits.join(' · ');
  const peek = $('code');
  const hasCode = !!(e?.file && e.line);
  $<HTMLButtonElement>('btn-sel-code').disabled = !hasCode;
  card.hidden = false;
  if (!hasCode) { peek.replaceChildren(); return; }
  const { from, to } = lineRange(e!);
  const last = Math.min(to, from + 3);
  const head = el('div', { className: 'ph' }, el('span', { textContent: e!.file! }), el('span', { textContent: `${to !== from ? 'Lines' : 'Line'} ${from}${to !== from ? '–' + to : ''}` }));
  try {
    const src = (await readText(e!.file!)).split(/\r?\n/);
    if (selection?.partId !== partId) return; // inzwischen etwas anderes gewählt
    peek.replaceChildren(head, ...codeRows(src.slice(from - 1, last), from, { from, to, kind: 'hl' }));
    if (to > last) peek.append(el('div', { className: 'ph', textContent: `… to line ${to}` }));
  } catch { peek.replaceChildren(head, el('div', { className: 'ph', textContent: `${e!.file} not readable` })); }
  if (codeOpen) void code.follow(e!.file!, { from, to, label: name, color: p?.color });
}

/** Text für die Eingabe des Agenten. Zahlen mit Punkt, damit sie eindeutig bleiben. */
function selectionText(): string | null {
  if (!selection) return null;
  // In der Dateiansicht gehören die Teile zur Datei, nicht zum Modell: Das muss der Agent wissen
  const inFile = fileView.rel ? ` in the ${fileView.kind} ${fileView.rel}` : '';
  if (picked.length > 1) {
    const names = picked.map((id) => `"${partName(id)}"`);
    return `[Selection: ${picked.length} parts${inFile}: ${names.slice(0, 40).join(', ')}${names.length > 40 ? ` and ${names.length - 40} more` : ''}] `;
  }
  const e = partEntry(selection.partId);
  const group = partInfo(selection.partId)?.group;
  const bits = [`part "${e?.name ?? partInfo(selection.partId)?.name ?? selection.partId}"${group ? ` in group "${group}"` : ''}${inFile}`];
  if (e?.file && e.line) { const { from, to } = lineRange(e); bits.push(`${e.file} ${to !== from ? 'lines' : 'line'} ${from}${to !== from ? '-' + to : ''}`); }
  const pk = selection.pick;
  if (pk?.faceId != null) {
    bits.push(`clicked face: ${surfaceName(pk.surface)}${pk.area != null ? `, ${pk.area.toFixed(1)} mm²` : ''}, point (${pk.point.map((v) => v.toFixed(1)).join(', ')}) mm`);
  }
  return `[Selection: ${bits.join(', ')}] `;
}

function errorText(): string | null {
  const e = buildStatus.state === 'error' ? buildStatus.result?.error : undefined;
  if (!e) return null;
  const where = e.file ? `${e.file}${e.line ? ` line ${e.line}` : ''}: ` : '';
  return `[Build error: ${where}${e.message.replace(/\s+/g, ' ').trim().slice(0, 400)}] `;
}

/** Fügt Text in die Eingabezeile des aktiven Terminals ein. Abschicken macht der Nutzer selbst (E11). `done` steht vor der Meldung. */
function insertToAgent(text: string | null, done?: string): void {
  if (!text) return;
  const pre = done ? `${done}\n` : '';
  // Immer auch in die Zwischenablage: Eine Agenten-App außerhalb der App (Claude Desktop, Codex-App) erreicht die Notiz nur so.
  // Ob im Terminal ein Agent läuft, lässt sich nicht für jeden Agenten verlässlich erkennen
  void api.copyText(text);
  if (!terminals.count) { toast(`${pre}Copied to the clipboard. Paste it into your agent, or start one with +.`, 'info'); return; }
  setAgentCollapsed(false);
  const title = terminals.insert(text);
  if (title) toast(`${pre}Added to the input of ${title}. Enter sends it. Also copied to the clipboard.`);
  else toast(`${pre}Copied to the clipboard. All terminals have ended, open a new one with +.`, 'info');
}

// ---- Messen (E9) ------------------------------------------------------------------------------------------------

const measureTool = new MeasureTool({
  card: $('measure-card'), body: $('measure-body'), button: $<HTMLButtonElement>('btn-measure'), close: $<HTMLButtonElement>('btn-measure-close'),
  again: $<HTMLButtonElement>('btn-measure-again'), agent: $<HTMLButtonElement>('btn-measure-agent'), viewerEl: $('viewer'),
}, {
  viewer,
  source: () => fileView.source ?? (versions.previewed ? { preview: versions.previewed.hash } : 'live'),
  build: () => map?.build ?? null,
  noGeometry: () => (map?.mesh ? 'Mesh files (STL, 3MF, AMF, OBJ) have no CAD geometry, so they cannot be measured. Open the STEP file or the model to measure.' : null),
  reload: () => void (fileView.active ? fileView.filesChanged() : loadModel()),
  part: (id) => partEntry(id),
  insert: (t) => insertToAgent(t),
});

// ---- Schnitt ----------------------------------------------------------------------------------------------------

const sectionTool = new SectionTool({
  card: $('section-card'), button: $<HTMLButtonElement>('btn-section'), close: $<HTMLButtonElement>('btn-section-close'),
  axes: $('section-axes'), label: $('section-label'), range: $<HTMLInputElement>('section-range'), value: $<HTMLInputElement>('section-value'),
  hint: $('section-hint'), flip: $<HTMLButtonElement>('btn-section-flip'), look: $<HTMLButtonElement>('btn-section-look'),
}, { viewer });

// ---- Zeichnungen (E76): Dokument „Drawings“ in der Code-Spalte, Ansichten und Maße in 3D --------------------------

const drawingLink = new DrawingLink({
  viewer, section: sectionTool,
  beforeShow: () => endOthers('drawing'),
  partIds: (names) => {
    const want = new Set(names);
    return viewer.partList().filter((p) => want.has(p.name) || want.has(p.id)).map((p) => p.id);
  },
  allIds: () => viewer.partList().map((p) => p.id),
  ready: () => viewer.partList().length > 0,
});
const drawingKey = (e: DrawingEntry) => `d:${e.id}:${e.built}`;
const drawingsView = () => code.pane(DRAWINGS_KEY) as DrawingsView | undefined;
const drawingsShown = () => codeOpen && code.activeFile === DRAWINGS_KEY;

/** Klick auf „Drawings“ an der Leiste: das Dokument zeigen, ist es schon vorne, die Code-Spalte schließen. */
function toggleDrawings(): void {
  if (drawingsShown()) { showCode(false); return; }
  // Blätter brauchen die Breite: Eine offene Seitenleiste geht zu, wie beim Wechsel zwischen ihren Reitern
  if (panel) showPanel(null);
  if (!codeOpen) { codeOpen = true; $('editor').hidden = false; $('split-code').hidden = false; renderLayout(); }
  code.openPane(DRAWINGS_KEY, 'Drawings', () => new DrawingsView({
    list: () => api.drawings.list(), build: (f) => api.drawings.build(f), readBinary: (rel) => api.fs.readBinary(rel),
    pdf: {
      quote: (file, pages, text) => {
        const cut = text.length > MAX_QUOTE;
        insertToAgent(`[Quote: ${file} p. ${pages}: "${cut ? `${text.slice(0, MAX_QUOTE)} …` : text}"] `, cut ? `Quote shortened to ${MAX_QUOTE} characters.` : undefined);
      },
      markPage: (file, page, canvas) => void markSource(`${file} p. ${page}`, canvas, canvas.width, canvas.height),
    },
    openCode: (file, line, label) => void openCode(file, line ? { from: line, to: line, label } : undefined),
    openFile: (rel) => void openCode(rel),
    insert: (t) => insertToAgent(t), toast, link: drawingLink,
    menu: $('menu-ctx'),
    exportFiles: async (what, sheet) => {
      const r = await api.drawings.export(what, sheet);
      if (r.cancelled) return;
      const name = (f: string) => f.split(/[\\/]/).pop() ?? f;
      const warn = r.warnings?.length ? `\n${r.warnings.join('\n')}` : '';
      if (!r.ok) toast(`Export failed: ${r.error}${warn}`, 'error');
      else if (r.files.length === 1) toast(`Exported:\n${r.target ?? r.files[0]}${warn}`, warn ? 'info' : 'ok');
      else toast(`${r.files.length} files exported to ${r.target ?? ''}:\n${r.files.map(name).join(', ')}${warn}`, warn ? 'info' : 'ok');
    },
    isNew: (e) => !seen.has(drawingKey(e)), seen: (e) => { seen.add(drawingKey(e)); },
    listed: (list) => { viewLists.drawings = list.drawings; renderResults(); },
  }));
  renderResults();
}

/** Knopf an der Leiste: gedrückt, solange das Dokument vorne in der offenen Code-Spalte steht. */
function renderDrawingsRail(): void {
  $('btn-rail-drawings').setAttribute('aria-pressed', String(drawingsShown()));
}
$('btn-rail-drawings').addEventListener('click', () => toggleDrawings());

// ---- Explosionsansicht (E56) ----------------------------------------------------------------------------------------

/** Ladeanzeige über dem Viewer, solange die Explosion rechnet. */
const busy = new Busy();
const explodeTool = new ExplodeTool({
  card: $('explode-card'), button: $<HTMLButtonElement>('btn-explode'), close: $<HTMLButtonElement>('btn-explode-close'),
  range: $<HTMLInputElement>('explode-range'), value: $('explode-value'), hint: $('explode-hint'),
  trails: $<HTMLButtonElement>('btn-explode-trails'), fit: $<HTMLButtonElement>('btn-explode-fit'), viewerEl: $('viewer'),
  back: $<HTMLButtonElement>('btn-explode-back'), play: $<HTMLButtonElement>('btn-explode-play'), next: $<HTMLButtonElement>('btn-explode-next'),
  step: $('explode-step'), send: $<HTMLButtonElement>('btn-explode-agent'),
}, {
  viewer,
  busy,
  insert: (t) => insertToAgent(t),
  beforeOn: () => { if (measureTool.isActive) measureTool.setActive(false); },
  settled: () => sectionTool.refresh(), // der Bereich des Schiebers folgt den verschobenen Bauteilen
});
// Gemessen wird in Einbaulage (die exakte Geometrie kennt keine Explosion): Messen setzt das Modell sofort zusammen.
// Nach dem Knopf-Handler von MeasureTool registriert, isActive ist hier schon umgeschaltet.
$('btn-measure').addEventListener('click', () => { if (measureTool.isActive) explodeTool.setActive(false, false); });

// ---- Markierung (E16) -------------------------------------------------------------------------------------------

const markup = new Markup({
  viewer: $('viewer'), layer: $('markup'), canvas: $<HTMLCanvasElement>('mark-canvas'), text: $<HTMLInputElement>('mark-text'),
  hint: $('mark-hint'), tools: $('mark-tools'), undo: $<HTMLButtonElement>('btn-mark-undo'), del: $<HTMLButtonElement>('btn-mark-delete'),
  blank: $<HTMLButtonElement>('btn-mark-blank'), grid: $<HTMLButtonElement>('btn-mark-grid'), colorBtn: $<HTMLButtonElement>('btn-mark-color'), colorSwatch: $('mark-color-sw'),
  palette: $('menu-mark-color'), custom: $<HTMLInputElement>('mark-color-custom'),
});

/** Friert die Ansicht ein, wie sie gerade ist (auch als Vorschau eines alten Stands, nur ohne Auswahl). Ohne Modell: leere Fläche. */
function startMarkup(): void {
  if (!project || markup.active) return;
  menus.close();
  markup.open(viewer.partList().length ? viewer.snapshot() : null);
}

/** Größte Kantenlänge der Zeichenfläche in Gerätepixeln: Große Fotos bleiben scharf, ohne dass die Fläche ausufert. */
const MARK_MAX_PX = 8192;

/**
 * Öffnet ein Bild aus dem Projekt als Hintergrund der Markierung. Die Zeichenfläche hat das Seitenverhältnis des Viewers,
 * das Bild wird unverzerrt eingepasst und behält seine Auflösung (so lesen Agenten auch feine Details einer Skizze).
 */
async function markImage(rel: string): Promise<void> {
  if (!project || !(await mayReplaceMarkup(rel))) return;
  let img: HTMLImageElement, url: string;
  try { url = await imageUrl(rel); } catch (e) { toast(`${rel} cannot be read: ${e instanceof Error ? e.message : String(e)}`, 'error'); return; }
  try {
    img = new Image();
    img.src = url;
    await img.decode();
  } catch {
    toast(`${rel} could not be loaded as an image. Right-click: “Open with default app”.`, 'error');
    return;
  } finally { URL.revokeObjectURL(url); }
  // SVG ohne Größenangabe meldet 0: dann einfach in Viewergröße
  const view = $('viewer');
  await markSource(rel, img, img.naturalWidth || view.clientWidth, img.naturalHeight || view.clientHeight, false);
}

/** Von Bild zu Bild wechseln geht direkt. Nur eine angefangene Zeichnung wird nicht still verworfen. */
async function mayReplaceMarkup(source: string): Promise<boolean> {
  menus.close();
  if (!markup.active) return true;
  if (markup.source === source) return false;
  if (!markup.drawn) return true;
  const c = await api.dialog.choose({ title: 'Markup', message: 'The open markup has not been sent to the agent yet.', detail: `Discard it and open ${source}?`, buttons: ['Discard and switch', 'Cancel'] });
  return c === 0;
}

/** Bild (Datei oder PDF-Seite) unverzerrt in eine Zeichenfläche im Seitenverhältnis des Viewers einpassen und öffnen. */
async function markSource(label: string, img: CanvasImageSource, iw: number, ih: number, ask = true): Promise<void> {
  if (!project || (ask && !(await mayReplaceMarkup(label)))) return;
  const view = $('viewer'), w = view.clientWidth, h = view.clientHeight;
  if (!w || !h || !iw || !ih) return;
  const scale = Math.min(Math.max(window.devicePixelRatio || 1, iw / w, ih / h), MARK_MAX_PX / Math.max(w, h));
  const c = document.createElement('canvas');
  c.width = Math.round(w * scale);
  c.height = Math.round(h * scale);
  const g = c.getContext('2d')!;
  g.fillStyle = getComputedStyle(document.documentElement).getPropertyValue('--s2').trim() || '#1b1e23';
  g.fillRect(0, 0, c.width, c.height);
  const f = Math.min(c.width / iw, c.height / ih);
  g.imageSmoothingQuality = 'high';
  g.drawImage(img, (c.width - iw * f) / 2, (c.height - ih * f) / 2, iw * f, ih * f);
  markup.close();
  markup.open(c, label);
}

async function sendMarkup(): Promise<void> {
  const btn = $<HTMLButtonElement>('btn-mark-send');
  if (btn.disabled || !markup.active) return;
  btn.disabled = true;
  try {
    const r = await api.fs.saveFeedback(await markup.image());
    // Ging das Speichern schief, bleibt die Zeichnung offen: Nichts geht verloren, der Nutzer kann es noch einmal versuchen
    if (!r.ok || !r.path) { toast(`The markup could not be saved: ${r.error ?? 'unknown error'}`, 'error'); return; }
    const old = versions.previewed, source = markup.source, shownFile = fileView.rel;
    markup.close();
    void refreshFiles(); // die neue Markierung steht gleich im Dateibaum
    // Zeigt das Bild einen alten Stand, einen Schnitt oder eine Explosion, soll der Agent das wissen (sonst vergleicht er es mit dem
    // aktuellen Code, hält die Schnittfläche für eine echte Fläche oder die auseinandergezogenen Teile für ihre Lage)
    // Auf einem Bild aus dem Projekt gezeichnet: Der Agent soll das Original kennen, Stand und Schnitt spielen dann keine Rolle
    const cut = [sectionTool.agentText(), explodeTool.agentText(), animTool.agentText(), resultTool.agentText()].filter(Boolean).join(', ');
    const note = source ? `, drawn on ${source}`
      : (old ? `, shows the older version ${old.short} "${old.subject.slice(0, 80)}"` : '')
        + (shownFile ? `, shows the STEP file ${shownFile}, not the model` : '') + (cut ? `, ${cut}` : '');
    insertToAgent(`[Markup: ${r.path}${note}] `, `Markup saved: ${r.path}`);
  } catch (e) {
    toast(`The markup could not be saved: ${e instanceof Error ? e.message : String(e)}`, 'error');
  } finally { btn.disabled = false; }
}

// ---- Animation, Analyse und Video (E58) -----------------------------------------------------------------------------

const resultLayer = new ResultLayer(viewer);
/** Zeigt der Viewer gerade eine Analyse oder Animation, sagen es Reiter, Baum und die Leiste unten im Bild (E82). */
/** Messen, Explosion, Animation und Analyse schließen sich aus: Jedes braucht das Modell in seiner eigenen Lage. */
const endOthers = (keep: 'measure' | 'explode' | 'anim' | 'result' | 'drawing') => {
  if (keep !== 'drawing') drawingLink.release();
  if (keep !== 'measure' && measureTool.isActive) measureTool.setActive(false);
  if (keep !== 'explode' && explodeTool.isActive) explodeTool.setActive(false, false);
  if (keep !== 'anim') animTool.setActive(false);
  if (keep !== 'result') resultTool.setActive(false);
};
const animTool = new AnimTool({
  bar: $('anim-bar'), close: $<HTMLButtonElement>('btn-anim-close'),
  play: $<HTMLButtonElement>('btn-anim-play'), range: $<HTMLInputElement>('anim-range'), time: $('anim-time'), total: $('anim-total'), ticks: $('anim-ticks'),
  loop: $<HTMLButtonElement>('btn-anim-loop'), follow: $<HTMLButtonElement>('btn-anim-follow'), texts: $<HTMLButtonElement>('btn-anim-texts'),
  speed: $<HTMLSelectElement>('anim-speed'), viewerEl: $('viewer'),
}, {
  viewer, list: () => api.anim.list(), build: (f) => api.anim.build(f), readBinary: (rel) => api.fs.readBinary(rel), renderVideo: (id) => api.render.video(id),
  beforeOn: () => endOthers('anim'), insert: (t) => insertToAgent(t), toast,
  showVideo: (rel) => { void refreshFiles(); seen.add(videoKey(rel)); scheduleViewLists(); void videoView.open(rel); },
  changed: () => renderResults(),
  tick: () => animPanel.tick(),
});
const resultTool = new ResultTool({
  legend: $('result-legend'), legendTitle: $('result-q'), legendBody: $('result-lg-body'), scaleBtn: $<HTMLButtonElement>('btn-result-scale'), scaleMode: $('result-scale-mode'),
  scaleMenu: $('menu-scale'), legendFull: $('result-q-full'), legendFoot: $('result-lg-foot'),
  range: $('result-range'), custom: $('result-custom'), lo: $<HTMLInputElement>('result-lo'), hi: $<HTMLInputElement>('result-hi'),
  bar: $('result-bar'), field: $('result-field'), deform: $('result-deform'), deformLabel: $('result-deform-label'), bcs: $<HTMLButtonElement>('btn-result-bcs'),
  name: $('result-name'), close: $<HTMLButtonElement>('btn-result-close'), viewerEl: $('viewer'),
}, {
  layer: resultLayer, viewer, list: () => api.results.list(), rerun: (id) => api.results.rerun(id), readBinary: (rel) => api.fs.readBinary(rel),
  beforeOn: () => endOthers('result'), toast,
  changed: () => renderResults(),
});
const analysisPanel = new AnalysisPanel({
  list: $('an-list'), listCount: $('an-count'), rows: $('an-rows'),
  report: $('an-report'), back: $<HTMLButtonElement>('btn-an-back'), backCount: $('an-back-count'), code: $<HTMLButtonElement>('btn-an-code'),
  more: $<HTMLButtonElement>('btn-an-more'), body: $('an-body'), pick: $('an-pick'), rerun: $<HTMLButtonElement>('btn-result-rerun'),
  agent: $<HTMLButtonElement>('btn-result-agent'), menu: $('menu-ctx'),
}, {
  tool: resultTool, insert: (t) => insertToAgent(t), openCode: (f) => void openCode(f),
  copy: (t) => void navigator.clipboard.writeText(t).then(() => toast(`Copied: ${t}`), (e) => toast(`Could not copy: ${e instanceof Error ? e.message : String(e)}`, 'error')),
  isNew: (r) => !seen.has(resultKey(r)), seen: (r) => { seen.add(resultKey(r)); },
});
const animPanel = new AnimPanel({
  list: $('am-list'), listCount: $('am-count'), rows: $('am-rows'),
  report: $('am-report'), back: $<HTMLButtonElement>('btn-am-back'), backCount: $('am-back-count'), code: $<HTMLButtonElement>('btn-am-code'),
  body: $('am-body'), video: $<HTMLButtonElement>('btn-anim-video'), agent: $<HTMLButtonElement>('btn-anim-agent'),
}, {
  tool: animTool, videos: () => viewLists.videos, openVideo: (rel) => void videoView.open(rel),
  openCode: (file, line) => void openCode(file, line ? { from: line, to: line, label: animTool.currentName ?? 'Animation' } : undefined),
  insert: (t) => insertToAgent(t), isNew: (k) => !seen.has(k), seen: (k) => { seen.add(k); },
  fileMenu: (rel, x, y) => files.menuFor(rel, x, y),
  closedDirs: () => { try { return project ? JSON.parse(store.get(`soma.anim.closedDirs.${project.id}`) ?? '[]') as string[] : []; } catch { return []; } },
  setClosedDirs: (dirs) => { if (project) store.set(`soma.anim.closedDirs.${project.id}`, JSON.stringify(dirs)); },
});
// Messen und Explosion schalten die beiden aus, bevor sie selbst anfangen (Lauscher in der Erfassungsphase laufen vor denen
// der Werkzeuge): Beide rechnen mit der Einbaulage
for (const [id, isOn] of [['btn-measure', () => measureTool.isActive], ['btn-explode', () => explodeTool.isActive]] as const) {
  $(id).addEventListener('click', () => { if (!isOn()) { animTool.setActive(false); resultTool.setActive(false); } }, true);
}
const videoView = new VideoView({
  root: $('videoview'), video: $<HTMLVideoElement>('video-el'), title: $('video-title'), play: $<HTMLButtonElement>('btn-video-play'),
  back: $<HTMLButtonElement>('btn-video-back'), fwd: $<HTMLButtonElement>('btn-video-fwd'), range: $<HTMLInputElement>('video-range'), time: $('video-time'),
  mark: $<HTMLButtonElement>('btn-video-mark'), agent: $<HTMLButtonElement>('btn-video-agent'), close: $<HTMLButtonElement>('btn-video-close'),
  mute: $<HTMLButtonElement>('btn-video-mute'), volume: $<HTMLInputElement>('video-volume'), more: $<HTMLButtonElement>('btn-video-more'),
}, {
  readBinary: (rel) => api.fs.readBinary(rel), insert: (t) => insertToAgent(t), toast,
  markFrame: (label, c) => markSource(label, c, c.width, c.height),
  fileMenu: (rel, x, y) => files.menuFor(rel, x, y), load: store.get, save: store.set,
});

$('btn-mark').addEventListener('click', startMarkup);
$('btn-mark-cancel').addEventListener('click', () => markup.close());
$('btn-mark-send').addEventListener('click', () => void sendMarkup());

/**
 * Rechtsklick auf ein Teil (Baum oder Bild). Ist es Teil einer Mehrfachauswahl, gilt das Menü für alle. Sonst wird es
 * ausgewählt, wie in CAD üblich. Die Tasten stehen daneben.
 */
function openPartMenu(id: string, x: number, y: number): void {
  if (picked.length > 1 && picked.includes(id)) { openSelectionMenu(x, y); return; }
  if (selection?.partId !== id) selectPart(id, null);
  const e = partEntry(id);
  const visible = viewer.isVisible(id);
  const ghost = viewer.isGhosted(id);
  const m = $('menu-ctx');
  const items: (HTMLElement | null)[] = [
    el('div', { className: 'mh', textContent: e?.name ?? partInfo(id)?.name ?? id }),
    menuItem('Isolate', { icon: 'target', kbd: 'I', onClick: () => { viewer.isolate(id); refreshTree(); } }),
    viewer.hiddenCount ? menuItem('Show all', { icon: 'eye', kbd: 'Shift H', onClick: () => { viewer.showAll(); refreshTree(); } }) : null,
    menuItem(visible ? 'Hide' : 'Show', { icon: visible ? 'eyeoff' : 'eye', kbd: visible ? 'H' : '', onClick: () => { viewer.setVisible(id, !visible); refreshTree(); } }),
    menuItem(ghost ? 'Not transparent' : 'Transparent', { icon: 'ghost', kbd: 'T', onClick: () => { viewer.setGhosted(id, !ghost); refreshTree(); } }),
    menuItem('Zoom to part', { icon: 'fit', onClick: () => viewer.focusPart(id) }),
    el('div', { className: 'msep' }),
    menuItem('Show code', { icon: 'code', disabled: !e?.file, onClick: () => { selectPart(id, null); if (e?.file && e.line) void openCode(e.file, { ...lineRange(e), label: e.name, color: partInfo(id)?.color }); } }),
    menuItem('Send to agent', { icon: 'send', onClick: () => { selectPart(id, null); insertToAgent(selectionText()); } }),
    menuItem('Export …', { icon: 'export', onClick: () => { selectPart(id, null); exportScope = 'sel'; openExportMenu(); } }),
  ];
  m.replaceChildren(...items.filter((x): x is HTMLElement => !!x));
  menus.at(m, x, y);
}

/** Rechtsklick auf eine Gruppe: dasselbe für alle ihre Teile. */
function openGroupMenu(ids: string[], name: string, x: number, y: number): void {
  const anyVisible = ids.some((id) => viewer.isVisible(id));
  const allGhost = ids.every((id) => viewer.isGhosted(id));
  const m = $('menu-ctx');
  const items: (HTMLElement | null)[] = [
    el('div', { className: 'mh', textContent: `${name} · ${ids.length} part${ids.length === 1 ? '' : 's'}` }),
    menuItem('Isolate', { icon: 'target', onClick: () => { viewer.isolate(ids); refreshTree(); } }),
    viewer.hiddenCount ? menuItem('Show all', { icon: 'eye', kbd: 'Shift H', onClick: () => { viewer.showAll(); refreshTree(); } }) : null,
    menuItem(anyVisible ? 'Hide' : 'Show', { icon: anyVisible ? 'eyeoff' : 'eye', onClick: () => { viewer.setVisible(ids, !anyVisible); refreshTree(); } }),
    menuItem(allGhost ? 'Not transparent' : 'Transparent', { icon: 'ghost', onClick: () => { viewer.setGhosted(ids, !allGhost); refreshTree(); } }),
    menuItem('Zoom to group', { icon: 'fit', onClick: () => viewer.setView('fit', ids) }),
  ];
  m.replaceChildren(...items.filter((x): x is HTMLElement => !!x));
  menus.at(m, x, y);
}

/** Rechtsklick auf mehrere ausgewählte Teile: Isolieren, Ausblenden, Transparent für alle. */
function openSelectionMenu(x: number, y: number): void {
  const ids = [...picked];
  const allGhost = ids.every((id) => viewer.isGhosted(id));
  const m = $('menu-ctx');
  const items: (HTMLElement | null)[] = [
    el('div', { className: 'mh', textContent: `${ids.length} parts selected` }),
    menuItem(`Isolate ${ids.length} parts`, { icon: 'target', kbd: 'I', onClick: () => selectionAction('isolate') }),
    menuItem(`Hide ${ids.length} parts`, { icon: 'eyeoff', kbd: 'H', onClick: () => selectionAction('hide') }),
    viewer.hiddenCount ? menuItem('Show all', { icon: 'eye', kbd: 'Shift H', onClick: () => selectionAction('showAll') }) : null,
    menuItem(allGhost ? 'Not transparent' : 'Transparent', { icon: 'ghost', kbd: 'T', onClick: () => selectionAction('ghost') }),
    menuItem('Zoom to selection', { icon: 'fit', onClick: () => viewer.setView('fit', ids) }),
    el('div', { className: 'msep' }),
    menuItem('Send to agent', { icon: 'send', onClick: () => insertToAgent(selectionText()) }),
    menuItem('Clear selection', { icon: 'x', kbd: 'Esc', onClick: () => selectPart(null, null) }),
  ];
  m.replaceChildren(...items.filter((x): x is HTMLElement => !!x));
  menus.at(m, x, y);
}

/** Rechtsklick ins Bild neben das Modell: alles einblenden, Auswahl aufheben. Ohne beides kein Menü. */
function openViewerMenu(x: number, y: number): void {
  const items: HTMLElement[] = [];
  if (viewer.hiddenCount) items.push(menuItem('Show all', { icon: 'eye', kbd: 'Shift H', onClick: () => selectionAction('showAll') }));
  if (picked.length) items.push(menuItem('Clear selection', { icon: 'x', kbd: 'Esc', onClick: () => selectPart(null, null) }));
  if (!items.length) return;
  $('menu-ctx').replaceChildren(...items);
  menus.at($('menu-ctx'), x, y);
}

/**
 * Was die Tasten H, Shift H, I und T tun (auch aus den Menüs). Ausgeblendete Teile verlassen die Auswahl, sonst wirkte die
 * nächste Taste auf Unsichtbares.
 */
function selectionAction(a: 'hide' | 'showAll' | 'isolate' | 'ghost'): void {
  const ids = [...picked];
  if (a === 'showAll') viewer.showAll();
  else if (!ids.length) { toast('Select parts first: click in the model or the tree, Ctrl or Shift for more, Alt + drag for a box.', 'info'); return; }
  else if (a === 'hide') { viewer.setVisible(ids, false); selectPart(null, null); }
  else if (a === 'isolate') viewer.isolate(ids);
  else viewer.setGhosted(ids, !ids.every((id) => viewer.isGhosted(id)));
  refreshTree();
}

// Tasten für die Auswahl (wie in CAD): H ausblenden, Shift H alles einblenden, I isolieren, T transparent, Esc Auswahl aufheben.
// Nicht beim Schreiben (Code, Terminal, Felder) und nicht, solange Markierung, Video, Einstellungen oder die Startseite offen sind
window.addEventListener('keydown', (e) => {
  if (!project || e.ctrlKey || e.altKey || e.metaKey || e.repeat || settings.isOpen || help.isOpen || !$('start').hidden) return;
  if ((e.target as HTMLElement | null)?.closest?.('#terminals, #code-view, input, textarea, select, [contenteditable=true]')) return;
  if (markup.active || !$('videoview').hidden) return;
  const k = e.key.toLowerCase();
  if (k === 'h' && e.shiftKey) selectionAction('showAll');
  else if (e.shiftKey) return;
  else if (k === 'h') selectionAction('hide');
  else if (k === 'i') selectionAction('isolate');
  else if (k === 't') selectionAction('ghost');
  // Escape gehört zuerst Menüs und Werkzeugen (Messen, Schnitt mit Flächenwahl, Ladeanzeige): nur ohne sie die Auswahl aufheben
  else if (e.key === 'Escape' && picked.length && !e.defaultPrevented && !measureTool.isActive && $('viewer-busy').hidden) selectPart(null, null);
  else return;
  e.preventDefault();
});

// ---- Build und Modell -------------------------------------------------------------------------------------------

/** Zuletzt gezeigter Fehler der Projektumgebung (E67): als Hinweis nur einmal. */
let shownPackageError = '';

function renderBuild(s: BuildStatus): void {
  buildStatus = s;
  if (s.state === 'ok') lastOkAt = s.builtAt ?? Date.now();
  if (s.state === 'error') errorAt = Date.now();
  const dot = $('build-dot'), main = $('status'), detail = $('status-detail');
  $('build-pill').classList.toggle('err', s.state === 'error' && !s.stale);
  $('btn-cancel').hidden = s.state !== 'building' || !!s.installing;
  $('btn-buildnow').hidden = !(s.stale && s.state !== 'building');
  const count = s.result?.parts?.length ?? 0;
  const secs = s.seconds ?? 0;
  dot.replaceChildren();
  dot.className = 'dot';
  dot.style.background = '';
  if (s.packageError && s.packageError !== shownPackageError) toast(s.packageError, 'error');
  shownPackageError = s.packageError ?? '';
  if (s.installing) {
    dot.className = 'spin';
    dot.append(icon('spin', 14, 2.4));
    main.textContent = 'Installing packages …';
    detail.textContent = s.installing.join(', ');
  } else if (s.state === 'building') {
    dot.className = 'spin';
    dot.append(icon('spin', 14, 2.4));
    main.textContent = 'Building …';
    detail.textContent = s.queued ? 'another build queued' : '';
  } else if (s.stale) {
    main.textContent = 'Code changed';
    detail.textContent = 'Auto build is off';
  } else if (s.state === 'ok') {
    dot.style.background = 'var(--ok)';
    main.textContent = 'Built';
    detail.textContent = `${count} part${count === 1 ? '' : 's'} · ${num(secs)} s`;
  } else if (s.state === 'error') {
    const e = s.result?.error;
    dot.style.background = 'var(--err)';
    main.textContent = 'Build failed';
    detail.textContent = e?.file ? `${e.file}${e.line ? `, line ${e.line}` : ''}` : ERROR_KIND[e?.kind ?? ''] ?? '';
  } else {
    main.textContent = 'Ready';
    detail.textContent = '';
  }
  void renderErrorCard();
}

async function renderErrorCard(): Promise<void> {
  const s = buildStatus;
  const e = s.state === 'error' && !showsOther() ? s.result?.error : undefined;
  const hasModel = viewer.partList().length > 0;
  $('viewer').classList.toggle('dim', !!e && hasModel);
  $('lastgood').hidden = !(e && hasModel && lastOkAt);
  if (lastOkAt) $('lastgood').textContent = `Last good version · ${fmtWhen(lastOkAt)}`;
  const card = $('errcard');
  if (!e) { card.hidden = true; return; }
  $('err-where').textContent = `${e.file ? `${e.file}${e.line ? `, line ${e.line}` : ''}` : ERROR_KIND[e.kind] ?? e.kind} · ${fmtWhen(errorAt)}`;
  $('err-msg').textContent = e.message;
  $('err-trace').textContent = e.traceback;
  $<HTMLButtonElement>('btn-err-details').disabled = !e.traceback;
  $<HTMLButtonElement>('btn-err-code').disabled = !e.file;
  card.hidden = false;
  const pc = $('err-code');
  pc.hidden = true;
  if (e.file && e.line) {
    try {
      const src = (await readText(e.file)).split(/\r?\n/);
      const a = Math.max(1, e.line - 1), b = Math.min(src.length, e.line + 2);
      pc.replaceChildren(...codeRows(src.slice(a - 1, b), a, { from: e.line, to: e.line, kind: 'er' }));
      pc.hidden = false;
    } catch { /* Datei nicht lesbar: Meldung reicht */ }
  }
}

/** Der Viewer zeigt gerade nicht das Modell, sondern einen alten Stand oder eine STEP-Datei: Builds warten. */
const showsOther = () => versions.previewing || fileView.active;

async function loadModel(): Promise<void> {
  if (showsOther()) return; // während einer Vorschau oder Dateiansicht bleibt deren Bild stehen
  const seq = ++loadSeq;
  const msg = $('viewer-msg');
  try {
    const [mapText, glb] = await Promise.all([api.fs.readText('.soma/model.map.json'), api.fs.readBinary('.soma/model.glb')]);
    if (seq !== loadSeq) return; // neuerer Build ist schon unterwegs
    map = JSON.parse(mapText) as ModelMap;
    textCache.clear();
    await viewer.load(glb);
    measureTool.reset(); // neuer Build: die Nummern der Flächen und Kanten gelten nicht mehr
    explodeTool.refresh(); // vor dem Schnitt: Dessen Bereich hängt von der Lage der Bauteile ab
    animTool.modelChanged(); // neue Bauteile: Lagen erneut anwenden, eine veraltete Animation neu bauen lassen
    if (resultTool.isActive) void resultTool.refresh();
    sectionTool.refresh();
    msg.className = ''; msg.textContent = '';
    refreshTree();
    // Flächen-IDs gelten nur für einen Build: nach dem Neuladen bleibt das Bauteil gewählt, die Fläche nicht
    // Mehrfachauswahl: was es nach dem Build noch gibt
    const still = picked.filter((id) => partInfo(id));
    if (selection && !partInfo(selection.partId)) setPicked(still, still.at(-1) ?? null);
    else if (selection) { selection.pick = null; setPicked(still, selection.partId); }
    void renderErrorCard();
    scheduleThumb();
  } catch (e) {
    msg.className = 'error';
    msg.textContent = `The model could not be loaded: ${e instanceof Error ? e.message : String(e)}`;
  }
}

let thumbTimer: ReturnType<typeof setTimeout> | undefined;
function scheduleThumb(): void {
  clearTimeout(thumbTimer);
  thumbTimer = setTimeout(() => {
    if (showsOther()) return;
    const url = viewer.thumbnail();
    if (url) void api.project.setThumb(url).catch(() => { /* Vorschaubild ist verzichtbar */ });
  }, 1500);
}

const versions = new VersionsBar({
  dots: $('vdots'), info: $('vinfo'), problem: $('vproblem'), restore: $<HTMLButtonElement>('btn-restore'), live: $<HTMLButtonElement>('btn-live'),
  banner: $('preview-banner'), bannerTitle: $('bn-title'), bannerSub: $('bn-sub'), viewer: $('viewer'),
}, {
  async show(res: PreviewResult | null, restored = false) {
    // Nach dem Wiederherstellen bleibt das Bild der Vorschau stehen, bis der Build danach fertig ist (er lädt dann wie jeder
    // Build von selbst). Sonst wäre so lange wieder der vorherige Build zu sehen, bei großen Modellen viele Sekunden. Braucht
    // der Stand erst Pakete (E67), kommt der Build nach der Installation.
    if (!res && restored && (buildStatus.state === 'building' || buildStatus.installing)) return;
    if (!res) { await loadModel(); return; }
    // Eine offene STEP-Datei macht der Vorschau Platz, ohne dazwischen das Modell zu laden
    if (fileView.active) { fileView.drop(); tree.setTitle(project?.name ?? ''); }
    await showForeign(res.glb, res.map, 'The preview');
  },
  toast,
  beforeRestore: () => leaveEditor('Restore version'), // Wiederherstellen ersetzt Dateien
});

/**
 * Zeigt einen fremden Stand (Vorschau eines alten Stands oder STEP-Datei) im Viewer. Animation und Analyse gehören zum
 * Modell und gehen aus, Messen, Explosion und Schnitt fangen auf dem neuen Bild von vorn an.
 */
async function showForeign(glb: ArrayBuffer, m: ModelMap, what: string): Promise<void> {
  loadSeq++; // ein noch laufendes Laden des Modells soll das Bild nicht überschreiben
  animTool.setActive(false);
  resultTool.setActive(false);
  try {
    map = m;
    textCache.clear();
    await viewer.load(glb);
    measureTool.reset();
    explodeTool.refresh();
    sectionTool.refresh();
    refreshTree();
    selectPart(null, null);
    void renderErrorCard();
  } catch (e) { toast(`${what} cannot be shown: ${e instanceof Error ? e.message : String(e)}`, 'error'); }
  renderResults();
}

const fileView = new FileView({
  banner: $('file-banner'), title: $('fb-title'), sub: $('fb-sub'), hint: $('fb-hint'), back: $<HTMLButtonElement>('btn-file-back'), viewer: $('viewer'),
}, {
  async show(res) {
    if (!res) { tree.setTitle(project?.name ?? ''); await loadModel(); return; }
    tree.setTitle(fileView.title ?? '');
    await showForeign(res.glb, res.map, 'The file');
    if (res.map.notes?.length) toast(res.map.notes.join('\n'), 'info');
  },
  beforeShow: () => versions.endPreview(),
  busy: (title, cancel) => busy.show(title, cancel),
  toast,
});

// ---- Projekt ----------------------------------------------------------------------------------------------------

async function onProject(p: ProjectInfo): Promise<void> {
  project = p;
  // Ein anderes Modell geöffnet (Menü, Startseite): Die Tour gehört zum Tutorial-Modell und endet
  if (tour.active && p.id !== tourProject) tour.stop(false, false);
  loadSeq++; // laufende Ladevorgänge des vorherigen Projekts verwerfen
  map = null;
  lastOkAt = null;
  textCache.clear();
  markup.close();
  if (measureTool.isActive) measureTool.setActive(false);
  sectionTool.setActive(false);
  explodeTool.setActive(false, false);
  animTool.setActive(false);
  resultTool.setActive(false);
  videoView.close();
  viewer.clear();
  versions.reset();
  fileView.drop();
  tree.setTitle(p.name);
  terminals.closeAll();
  code.reset();
  skills.reset();
  if (panel === 'skills') void skills.refresh();
  paramsPanel.reset();
  if (panel === 'params') void paramsPanel.refresh();
  if (codeOpen) void code.open(p.entry); // die Code-Spalte bleibt offen, dann nicht leer
  // Ordner-Modus: Der Ordner ist das Modell (kein Speichern als .soma), den Verlauf gibt es nur zum Ansehen
  versions.setReadOnly(p.folder);
  $('btn-save').hidden = $('btn-saveas').hidden = p.folder;
  resetViewLists();
  applyDisplayDefaults();
  selection = null;
  picked = [];
  void renderSelection();
  tree.message('Building the model …');
  $('doc-name').textContent = p.name;
  document.title = `SOMA – ${p.name}`;
  $<HTMLInputElement>('chk-auto').checked = p.autoBuild;
  renderAuto();
  showProblems(p.problems);
  filesDirty = true;
  if (panel === 'files') void refreshFiles();
  void versions.refresh();
  void refreshSaveState();
  void terminals.add({ title: 'Terminal' });
  void refreshAgents();
  const st = await api.build.status();
  renderBuild(st);
  if (st.state === 'ok') void loadModel();
}

function showProblems(problems: string[]): void {
  const b = $('problems');
  b.hidden = problems.length === 0;
  b.replaceChildren(icon('alert', 14, 2), `${problems.length} issue${problems.length === 1 ? '' : 's'}`);
  b.title = problems.join('\n');
  $('problem-list').replaceChildren(...problems.map((p) => el('div', { className: 'problem' }, el('span', { className: 'pi' }, icon('alert', 16)), el('span', { textContent: p }))));
}

async function refreshAgents(): Promise<void> {
  try { agents = await api.agents.detect(); } catch { agents = []; }
}

// ---- Speichern und Öffnen ---------------------------------------------------------------------------------------

function renderSaveState(st: SaveState): void {
  saveState = st;
  const dot = el('span', { className: 'dot' });
  let text: string;
  // Ungespeichertes im Editor zählt mit, auch wenn die Dateien auf der Platte dem gespeicherten Stand entsprechen
  const unsaved = st.unsaved || code.unsaved().length > 0;
  if (project?.folder) { dot.style.background = unsaved ? 'var(--warn)' : 'var(--ok)'; text = unsaved ? 'Folder · unsaved edits' : 'Folder'; }
  else if (!st.zipPath) { dot.style.background = 'var(--warn)'; text = 'Not saved yet'; }
  else if (unsaved) { dot.style.background = 'var(--warn)'; text = `Not saved${st.savedAt ? ` · last ${fmtWhen(st.savedAt)}` : ''}`; }
  else { dot.style.background = 'var(--ok)'; text = `Saved${st.savedAt ? ` · ${fmtWhen(st.savedAt)}` : ''}`; }
  const b = $('save-badge');
  b.replaceChildren(dot, text);
  b.title = project?.folder ? `Folder: ${project.dir}\nChanges are saved in the folder itself.` : st.zipPath ? `File: ${st.zipPath}` : 'Not saved yet. Ctrl+S saves.';
  versions.setSaved(st.zipPath ? st.savedHead : null);
  document.title = `SOMA – ${project?.name ?? ''}${unsaved ? ' ●' : ''}`;
}

async function refreshSaveState(): Promise<void> {
  try { renderSaveState(await api.project.saveState()); } catch { /* Projekt wechselt gerade */ }
}

/**
 * Strg+S im Editor und „Speichern und bauen“: geänderte Dateien schreiben. Gebaut wird nur, wenn darunter eine ist,
 * die das Modell betrifft (Python, inputs/). Keine Modelldatei, kein Snapshot, das macht „Speichern“ oben.
 */
async function saveCode(): Promise<void> {
  const r = await code.saveAll();
  if (!r.ok) { toast('Not everything could be saved (see the note in the code). The build waits until then.', 'error'); return; }
  if (r.saved.some(affectsBuild)) await api.build.run();
}

/** Vor Modellwechsel und Wiederherstellen: ungespeicherte Eingaben im Editor nicht still verlieren. false = abbrechen. */
async function leaveEditor(title: string): Promise<boolean> {
  const files = code.unsaved();
  if (!files.length) return true;
  const c = await api.dialog.choose({
    title, message: `The editor has unsaved changes: ${files.join(', ')}.`,
    detail: 'Discard keeps your version as a backup in the app data.', buttons: ['Save', 'Discard', 'Cancel'],
  });
  if (c === 0) {
    const r = await code.saveAll();
    if (!r.ok) toast('Not everything could be saved (see the note in the code panel).', 'error');
    return r.ok;
  }
  return c === 1 ? code.discardAll() : false;
}

let saving = false;
/**
 * Speichern kann dauern (ein laufender oder veralteter Build wird abgewartet, dann Snapshot und .soma-Datei): Der Knopf zeigt das
 * sofort, weitere Klicks und Strg+S zählen solange nicht.
 */
async function doSave(saveAs = false): Promise<void> {
  if (saving) return;
  // Ordner-Modus: Strg+S schreibt nur die Eingaben im Editor in den Ordner, eine .soma-Datei gibt es nicht
  if (project?.folder) {
    const c = await code.saveAll();
    if (!c.ok) toast('Not everything in the editor could be saved (see the note in the code).', 'error');
    else if (c.saved.length) { toast(`Saved in the folder: ${c.saved.join(', ')}`, 'ok'); if (c.saved.some(affectsBuild)) await api.build.run(); }
    else toast('Nothing to save. This model is the folder itself. Export › Everything as ZIP makes a copy as a file.', 'info');
    void refreshSaveState();
    return;
  }
  saving = true;
  const btn = $<HTMLButtonElement>('btn-save');
  const label = btn.innerHTML;
  btn.disabled = true;
  btn.classList.add('busy');
  btn.replaceChildren(el('span', { className: 'spin' }, icon('spin', 14, 2.4)), 'Saving …');
  try {
    // Erst die Eingaben im Editor, sonst fehlten sie in Snapshot und Datei. Das Speichern baut danach, falls nötig.
    const c = await code.saveAll();
    if (!c.ok) { toast('Not everything in the editor could be saved (see the note in the code). So the model is not saved.', 'error'); return; }
    const r = await api.project.save(saveAs);
    if (r.cancelled) return;
    if (r.error) { toast(r.error, 'error'); return; }
    const kb = Math.round((r.bytes ?? 0) / 1024);
    const lines = [`Saved: ${r.zipPath}`, `${r.files} file${r.files === 1 ? '' : 's'}, ${kb} KB${r.snapshot ? ' · snapshot added to the history' : ''}`];
    if (r.warnings?.length) lines.push(`Note: ${r.warnings.join(' ')}`);
    toast(lines.join('\n'), r.warnings?.length ? 'error' : 'ok');
    project = await api.project.current(); // der Modellname folgt dem Dateinamen
    $('doc-name').textContent = project.name;
    tree.setTitle(fileView.title ?? project.name);
    void refreshSaveState();
  } finally {
    saving = false;
    btn.disabled = false;
    btn.classList.remove('busy');
    btn.innerHTML = label; // fester Text aus index.html, kein Text aus dem Projekt
  }
}

async function doOpen(): Promise<boolean> {
  if (!(await leaveEditor('Open model'))) return false;
  const r = await api.project.openZip();
  if (r.error) toast(r.error, 'error');
  return !!r.opened;
}

const doNew = async () => { if (await leaveEditor('New model')) await api.project.create(); };
// Ladeanzeige für den Import: erscheint mit dem ersten Schritt nach dem Dateidialog, zählt die Sekunden mit
let cqBusyTick: ReturnType<typeof setInterval> | undefined;
api.project.onCadQueryStep(({ step, file }) => {
  const root = $('app-busy');
  if (root.hidden) {
    const t0 = performance.now();
    $('app-busy-time').textContent = '';
    clearInterval(cqBusyTick);
    cqBusyTick = setInterval(() => { $('app-busy-time').textContent = `${Math.round((performance.now() - t0) / 1000)} s`; }, 1000);
    root.hidden = false;
  }
  $('app-busy-step').textContent = `${step} …`;
  $('app-busy-file').textContent = file;
});
function closeCadQueryBusy(): void {
  clearInterval(cqBusyTick);
  $('app-busy').hidden = true;
}

/** Neues Modell aus einem CadQuery-Skript (E100). Die Hinweise des Imports (Kompatibilitätsmodus, Werte) zeigt ein Toast. */
/** „Open folder“ (Ordner-Modus): Fragen und Hinweis stellt der Hauptprozess. */
async function doOpenFolder(): Promise<boolean> {
  if (!(await leaveEditor('Open folder'))) return false;
  const r = await api.project.openFolder().catch((e: unknown) => ({ cancelled: false, opened: false, error: e instanceof Error ? e.message : String(e) }));
  if (r.error) toast(r.error, 'error');
  return !!r.opened;
}

async function doNewFromCadQuery(): Promise<CadQueryImportResult | null> {
  if (!(await leaveEditor('New model'))) return null;
  let r: CadQueryImportResult;
  try { r = await api.project.createFromCadQuery(); } finally { closeCadQueryBusy(); }
  if (r.cancelled) return r;
  if (r.error) { toast(r.error, 'error'); return r; }
  showStart(false);
  toast(['Model created from the CadQuery script. The original is kept in inputs/.', ...r.warnings].join('\n'), 'info');
  return r;
}
/** „Jetzt bauen“: baut immer. Vorher werden die Eingaben im Editor gespeichert, sonst sähe der Build sie nicht. */
async function doBuild(): Promise<void> {
  const r = await code.saveAll();
  if (!r.ok) { toast('Not everything could be saved (see the note in the code panel). The build waits until then.', 'error'); return; }
  await api.build.run();
}
const openProject = async (id: string) => {
  if (!(await leaveEditor('Open model'))) return;
  // Ein geöffneter Ordner kann fehlen (verschoben, Laufwerk ab): Der Hauptprozess sagt es
  await api.project.open(id).catch((e: unknown) => toast(String(e instanceof Error ? e.message : e).replace(/^Error invoking remote method '[^']+': (Error: )?/, ''), 'error'));
};

// F3 klappt den Strukturbaum auf und zu wie in CATIA (E82, Vorschlag aus dem Entwurf). Nicht beim Schreiben in Code, Terminal oder Feldern
window.addEventListener('keydown', (e) => {
  if (e.key !== 'F3' || e.ctrlKey || e.altKey || e.shiftKey || !project || settings.isOpen || help.isOpen || !$('start').hidden) return;
  if ((e.target as HTMLElement | null)?.closest?.('#terminals, #code-view, input, textarea, select, [contenteditable=true]')) return;
  e.preventDefault();
  tree.setOpen(!tree.isOpen);
});

// Kurzbefehle gelten nicht im Terminal: dort gehören Strg+S/Strg+O den Programmen (Claude Code nutzt Strg+O selbst)
window.addEventListener('keydown', (e) => {
  // Die Einstellungen liegen über allem und haben eigene Kurzbefehle (Strg+S speichert den Skill), die Hilfe ebenso
  if (settings.isOpen || help.isOpen || (e.target as HTMLElement | null)?.closest?.('#terminals') || !e.ctrlKey || e.altKey) return;
  const k = e.key.toLowerCase();
  // Ohne offenes Modell (Startseite beim Start, E69) gibt es nur Neu und Öffnen
  if (!project && k !== 'n' && k !== 'o') return;
  // Im Editor speichert Strg+S den Code und baut, sonst das ganze Modell als .soma-Datei
  if (k === 's') { e.preventDefault(); if (!e.shiftKey && (e.target as HTMLElement | null)?.closest?.('#code-view')) void saveCode(); else void doSave(e.shiftKey); }
  else if (k === 'o' && !e.shiftKey) { e.preventDefault(); void doOpen().then((ok) => { if (ok) showStart(false); }); }
  else if (k === 'n' && !e.shiftKey) { e.preventDefault(); void doNew().then(() => showStart(false)); }
  else if (k === 'b' && !e.shiftKey) { e.preventDefault(); void doBuild(); }
  else if (k === '1' && !e.shiftKey) { e.preventDefault(); toggleSide(); }
  else if (k === '2' && !e.shiftKey) { e.preventDefault(); showCode(!codeOpen); }
  else if (k === '3' && !e.shiftKey) { e.preventDefault(); setAgentCollapsed(!$('terminals').classList.contains('collapsed')); }
}, true);

// ---- Menüs der Kopfzeile ----------------------------------------------------------------------------------------

async function renderRecent(): Promise<void> {
  let list: { id: string; name: string; modified: number }[] = [];
  try { list = await api.project.list(); } catch { /* ohne Liste */ }
  list.sort((a, b) => b.modified - a.modified);
  const others = list.filter((p) => p.id !== project?.id).slice(0, 6);
  $('recent-wrap').hidden = others.length === 0;
  $('recent-list').replaceChildren(...others.map((p) => menuItem(p.name, { icon: 'cube', sub: fmtWhen(p.modified, true), onClick: () => void openProject(p.id) })));
}

$('btn-doc').addEventListener('click', () => { void renderRecent().then(() => menus.toggle($('menu-doc'), $('btn-doc'))); });
$('btn-new').addEventListener('click', () => void doNew());
$('btn-new-cq').addEventListener('click', () => { menus.close(); void doNewFromCadQuery(); });
$('btn-open').addEventListener('click', () => void doOpen());
$('btn-open-folder').addEventListener('click', () => { menus.close(); void doOpenFolder().then((ok) => { if (ok) showStart(false); }); });
$('btn-save').addEventListener('click', () => void doSave(false));
$('btn-save-menu').addEventListener('click', () => void doSave(false));
$('btn-saveas').addEventListener('click', () => void doSave(true));
$('btn-reveal').addEventListener('click', () => void api.project.reveal());
$('btn-reveal-menu').addEventListener('click', () => void api.project.reveal());
$('btn-start').addEventListener('click', () => showStart(true));
$('btn-home').addEventListener('click', () => showStart(true));
// Versionsnummer (E68): neben dem Namen auf der Startseite und im Hinweis des Logos
$('start-version').textContent = SOMA_VERSION;
$('btn-home').title = `Start page · SOMA ${SOMA_VERSION}`;
$('problems').addEventListener('click', () => menus.toggle($('menu-problems'), $('problems')));

// Build
function renderAuto(): void {
  const on = $<HTMLInputElement>('chk-auto').checked;
  $('auto-label').textContent = on ? 'Auto on' : 'Auto off';
  $('btn-auto').title = on ? 'Builds automatically when the code changes. Click to turn off.' : 'Auto build is off. Click to turn on.';
}
$<HTMLInputElement>('chk-auto').addEventListener('change', (e) => { renderAuto(); void api.build.setAuto((e.target as HTMLInputElement).checked); });
$('btn-auto').addEventListener('click', () => { const c = $<HTMLInputElement>('chk-auto'); c.checked = !c.checked; c.dispatchEvent(new Event('change')); });
$('btn-build').addEventListener('click', () => void doBuild());
$('btn-buildnow').addEventListener('click', () => void doBuild());
$('btn-cancel').addEventListener('click', () => void api.build.cancel());
$('btn-buildinfo').addEventListener('click', () => {
  const s = buildStatus;
  const count = s.result?.parts?.length ?? 0;
  const secs = s.seconds ?? 0;
  const warn = s.result?.warnings ?? [];
  $('bm-title').textContent = s.state === 'error' ? 'Last build failed' : s.state === 'building' ? 'Build running' : lastOkAt ? `Last built ${fmtWhen(lastOkAt)}` : 'Not built yet';
  $('bm-sub').textContent = s.state === 'ok' ? `${num(secs)} s · ${count} part${count === 1 ? '' : 's'} · ${warn.length ? `${warn.length} warning${warn.length === 1 ? '' : 's'}` : 'no warnings'}` : '';
  $('bm-warn').hidden = !warn.length;
  $('bm-warn').textContent = warn.join('\n');
  menus.toggle($('menu-build'), $('btn-buildinfo'));
});

// Darstellung
$('btn-display').addEventListener('click', () => menus.toggle($('menu-display'), $('btn-display'), 'beside'));
$('btn-axes').addEventListener('click', () => setAxes($('btn-axes').getAttribute('aria-pressed') !== 'true'));
document.querySelectorAll<HTMLButtonElement>('[data-display]').forEach((b) => b.addEventListener('click', () => {
  const on = b.getAttribute('aria-checked') !== 'true';
  b.setAttribute('aria-checked', String(on));
  if (b.dataset.display === 'edges') viewer.setEdges(on);
  else if (b.dataset.display === 'wire') viewer.setWireframe(on);
  else if (b.dataset.display === 'axes') setAxes(on);
  else viewer.setGhost(on);
}));

// Export
let exportScope: 'all' | 'sel' = 'all';
function renderExportScope(): void {
  const e = selection ? partEntry(selection.partId) : undefined;
  const name = e?.name ?? (selection ? partInfo(selection.partId)?.name : undefined);
  const sel = $<HTMLButtonElement>('exp-sel');
  sel.disabled = !name;
  sel.textContent = name ? `Only ${name}` : 'Selection only';
  if (!name) exportScope = 'all';
  $('exp-all').classList.toggle('on', exportScope === 'all');
  sel.classList.toggle('on', exportScope === 'sel');
  $('exp-all').setAttribute('aria-pressed', String(exportScope === 'all'));
  sel.setAttribute('aria-pressed', String(exportScope === 'sel'));
}
function openExportMenu(anchor: HTMLElement = $('btn-export')): void {
  renderExportScope();
  const m = $('menu-export');
  if (!menus.isOpen(m)) setMeshOptsOpen(false);
  if (!menus.isOpen(m)) menus.toggle(m, anchor, anchor.id === 'btn-export' ? 'right' : 'left');
}
$('btn-export').addEventListener('click', () => {
  if (menus.isOpen($('menu-export'))) { menus.close(); return; }
  exportScope = selection ? exportScope : 'all';
  openExportMenu();
});
$('btn-sel-export').addEventListener('click', () => {
  if (menus.isOpen($('menu-export'))) { menus.close(); return; }
  exportScope = 'sel';
  openExportMenu($('btn-sel-export'));
});
// Netz-Einstellungen (Issue #8): gemerkt in diesem Fenster, leer heißt die Vorgabe des Formats in `soma export`
const MESH_OPTS_KEY = 'soma.exportMesh';
let meshOpts: MeshExportOptions = (() => {
  try {
    const o = JSON.parse(store.get(MESH_OPTS_KEY) ?? '{}') as Record<string, unknown>;
    return {
      ...(o.units === 'mm' || o.units === 'm' ? { units: o.units } : {}),
      ...(o.up === 'z' || o.up === 'y' ? { up: o.up } : {}),
      ...(o.detail === 'coarse' || o.detail === 'fine' ? { detail: o.detail } : {}),
    };
  } catch { return {}; }
})();
const MESH_SEGS: [string, keyof MeshExportOptions, string][] = [['exp-units', 'units', ''], ['exp-up', 'up', ''], ['exp-detail', 'detail', 'normal']];
function renderMeshOpts(): void {
  for (const [id, key, dflt] of MESH_SEGS) {
    const cur = meshOpts[key] ?? dflt;
    for (const b of $(id).querySelectorAll<HTMLButtonElement>('button')) {
      b.classList.toggle('on', b.dataset.v === cur);
      b.setAttribute('aria-pressed', String(b.dataset.v === cur));
    }
  }
  // Zugeklappt zeigt die Zeile, was vom Normalfall abweicht, damit eine Einstellung von früher nicht übersehen wird
  const { units, up, detail } = meshOpts;
  const sum = [units, up && `${up.toUpperCase()} up`, detail && detail[0].toUpperCase() + detail.slice(1)].filter(Boolean).join(' · ');
  $('exp-mesh-sum').textContent = sum || 'Auto';
}
/** Netz-Einstellungen auf- oder zuklappen. Normalerweise braucht man sie nicht, deshalb startet das Menü zugeklappt. */
function setMeshOptsOpen(open: boolean): void {
  $('exp-mesh').hidden = !open;
  $('exp-mesh-toggle').setAttribute('aria-expanded', String(open));
}
$('exp-mesh-toggle').addEventListener('click', () => setMeshOptsOpen($('exp-mesh').hidden));
for (const [id, key, dflt] of MESH_SEGS) {
  $(id).addEventListener('click', (ev) => {
    const b = (ev.target as HTMLElement).closest<HTMLButtonElement>('button[data-v]');
    if (!b) return;
    const v = b.dataset.v ?? '';
    const next: Record<string, string> = { ...meshOpts };
    if (v && v !== dflt) next[key] = v; else delete next[key];
    meshOpts = next as MeshExportOptions;
    store.set(MESH_OPTS_KEY, JSON.stringify(meshOpts));
    renderMeshOpts();
  });
}
renderMeshOpts();
$('exp-all').addEventListener('click', () => { exportScope = 'all'; renderExportScope(); });
$('exp-sel').addEventListener('click', () => { exportScope = 'sel'; renderExportScope(); });
document.querySelectorAll<HTMLButtonElement>('#menu-export [data-fmt]').forEach((b) => b.addEventListener('click', () => void doExport(b.dataset.fmt!, b.textContent!)));
$('exp-zip').addEventListener('click', () => { menus.close(); void doExportZip(); });
$('exp-cq').addEventListener('click', () => { menus.close(); void doExportCadQuery(); });

/** Das Modell als reines CadQuery (E100). Wie beim ZIP fehlen Eingaben, die im Editor noch nicht gespeichert sind. */
async function doExportCadQuery(): Promise<ExportResult> {
  const r = await api.project.exportCadQuery();
  if (r.cancelled) return r;
  const open = code.unsaved();
  if (r.ok) {
    const notes = [...(r.warnings ?? []), ...(open.length ? [`Not included (not saved in the editor): ${open.join(', ')}`] : [])];
    toast([`Model exported as CadQuery:\n${r.target ?? ''}`, ...notes].join('\n'), open.length ? 'error' : 'ok');
  } else toast(r.error ?? 'Export failed', 'error');
  return r;
}

/**
 * Das ganze Modell als ZIP (E79). Eingaben im Editor, die noch nicht gespeichert sind, fehlen darin wie in jedem Export:
 * Die Meldung nennt sie, statt sie ungefragt zu speichern.
 */
async function doExportZip(): Promise<ExportResult> {
  const r = await api.project.exportZip();
  if (r.cancelled) return r;
  const open = code.unsaved();
  if (r.ok) {
    const notes = [...(r.warnings ?? []), ...(open.length ? [`Not included (not saved in the editor): ${open.join(', ')}`] : [])];
    toast([`Model exported as ZIP:\n${r.target ?? ''}`, ...notes].join('\n'), notes.length ? 'error' : 'ok');
  } else toast(r.error ?? 'Export failed', 'error');
  return r;
}

/** Exportieren: Der Hauptprozess fragt nach Datei (ein Bauteil) oder Ordner (alle Bauteile) und schreibt erst danach. */
async function doExport(fmt: string, label: string): Promise<ExportResult> {
  menus.close();
  const e = selection ? partEntry(selection.partId) : undefined;
  const part = exportScope === 'sel' ? e?.name ?? partInfo(selection?.partId ?? '')?.name ?? null : null;
  const r = await api.build.export(fmt, part, meshOpts);
  if (r.cancelled) return r;
  const name = (f: string) => f.split(/[\\/]/).pop() ?? f;
  // Hinweise von soma (Netz nicht geschlossen, welche Flächen) gehören dazu: Bericht statt stiller Reparatur (E28)
  const warn = r.warnings?.length ? `\n${r.warnings.join('\n')}` : '';
  if (r.ok && part) toast(`“${part}” exported as ${label}:\n${r.target ?? r.files[0] ?? ''}${warn}`, warn ? 'error' : 'ok');
  else if (r.ok) toast(`${r.files.length} file${r.files.length === 1 ? '' : 's'} exported as ${label} to ${r.target ?? ''}:\n${r.files.map(name).join(', ') || '(no file)'}${warn}`, warn ? 'error' : 'ok');
  else toast(`Export failed: ${r.error}`, 'error');
  return r;
}

// ---- Ergebnisse des Agenten in den Reitern Analysis und Animation (E82) ----------------------------------------------
// Analysen, Animationen und Videos sind Ergebnisse des Agenten, keine Werkzeuge. Ein Klick auf den Reiter zeigt die Liste (oder
// den Bericht, wenn schon ein Ergebnis im Bild ist), erst ein Klick in der Liste bringt eins in den Viewer. Das × in der Leiste unten im Bild führt zurück zum Modell.

let viewLists: { results: ResultEntry[]; anims: AnimEntry[]; videos: string[]; drawings: DrawingEntry[] } = { results: [], anims: [], videos: [], drawings: [] };
/** Angesehene Ergebnisse (Schlüssel). Was danach dazukommt, steht in der Liste als „new“, bis man es öffnet. */
const seen = new Set<string>();
/** Ergebnisse, die schon in einem geöffneten Reiter standen. Was nicht darin ist, gibt dem Reiter einen Punkt. */
const tabSeen = new Set<string>();
let seenReady = false;
let viewSeq = 0;
let viewTimer: ReturnType<typeof setTimeout> | undefined;

const resultKey = (r: ResultEntry) => `r:${r.id}:${String(r.created ?? '')}`;
const analysisKeys = () => viewLists.results.map(resultKey);
const animKeys = () => [...viewLists.anims.map(animKey), ...viewLists.videos.map(videoKey)];
const drawingKeys = () => viewLists.drawings.map(drawingKey);

function videosIn(nodes: FileNode[], out: string[] = []): string[] {
  for (const n of nodes) {
    if (n.dir) { if (!n.name.startsWith('.')) videosIn(n.children ?? [], out); }
    else if (VIDEO_EXT.test(n.name)) out.push(n.path);
  }
  return out;
}

function resetViewLists(): void {
  viewSeq++;
  viewLists = { results: [], anims: [], videos: [], drawings: [] };
  seen.clear();
  tabSeen.clear();
  seenReady = false;
  renderResults();
  void refreshViewLists();
}

async function refreshViewLists(): Promise<void> {
  if (!project) return;
  const seq = ++viewSeq;
  const [results, anims, nodes, drawings] = await Promise.all([
    api.results.list().catch(() => null), api.anim.list().catch(() => null), api.fs.list().catch(() => [] as FileNode[]),
    api.drawings.list().catch(() => null as DrawingList | null),
  ]);
  if (seq !== viewSeq) return;
  viewLists = { results: results ?? viewLists.results, anims: anims?.animations ?? viewLists.anims, videos: videosIn(nodes), drawings: drawings?.drawings ?? viewLists.drawings };
  if (results) resultTool.setList(results);
  if (anims) animTool.setList(anims);
  // Was beim Öffnen des Modells schon da ist, gilt als gesehen
  if (!seenReady) { for (const k of [...analysisKeys(), ...animKeys(), ...drawingKeys()]) { seen.add(k); tabSeen.add(k); } seenReady = true; }
  renderResults();
}
const scheduleViewLists = () => { clearTimeout(viewTimer); viewTimer = setTimeout(() => void refreshViewLists(), 400); };

/** Reiter, Punkte an der Leiste und Baum nachziehen: Was zeigt der Viewer, was ist neu? */
function renderResults(): void {
  // Ein offener Reiter zeigt das Neue selbst (in der Liste), dort braucht es keinen Punkt
  if (panel === 'analysis') for (const k of analysisKeys()) tabSeen.add(k);
  if (panel === 'anim') for (const k of animKeys()) tabSeen.add(k);
  $('nd-analysis').hidden = !analysisKeys().some((k) => !tabSeen.has(k));
  $('nd-anim').hidden = !animKeys().some((k) => !tabSeen.has(k));
  if (drawingsShown()) for (const k of drawingKeys()) tabSeen.add(k);
  $('nd-drawings').hidden = !drawingKeys().some((k) => !tabSeen.has(k));
  renderDrawingsRail();
  if (panel === 'analysis') analysisPanel.render();
  if (panel === 'anim') animPanel.render();
  // In der Analyse stehen im Baum nur die gerechneten Körper, gegliedert wie im Modell
  const r = resultTool.shown;
  tree.limit(r ? r.parts.map((x) => x.name) : null);
  fitDock();
}

/** Reiter Analysis oder Animation geöffnet: Liste frisch laden. Von selbst kommt nichts ins Bild, das wählt der Nutzer in der Liste. */
async function openResults(): Promise<void> {
  analysisPanel.opened();
  await refreshViewLists();
}

async function openAnims(): Promise<void> {
  animPanel.opened();
  await refreshViewLists();
}

// ---- Viewer-Bedienung -------------------------------------------------------------------------------------------

// Einpassen, Standardansicht und die Ansichten im Menü „Darstellung“ (der Würfel selbst steuert über viewcube.ts)
document.querySelectorAll<HTMLButtonElement>('[data-view]').forEach((b) => b.addEventListener('click', () => viewer.setView(b.dataset.view as ViewName)));
$('btn-sel-close').addEventListener('click', () => selectPart(null, null));
$('btn-sel-code').addEventListener('click', () => {
  const e = selection ? partEntry(selection.partId) : undefined;
  if (e?.file && e.line) void openCode(e.file, { ...lineRange(e), label: e.name, color: partInfo(e.id)?.color });
});
$('btn-sel-agent').addEventListener('click', () => insertToAgent(selectionText()));
$('btn-err-agent').addEventListener('click', () => insertToAgent(errorText()));
$('btn-err-code').addEventListener('click', () => {
  const e = buildStatus.result?.error;
  if (e?.file) void openCode(e.file, e.line ? { from: e.line, to: e.line, label: 'Build error', kind: 'er' } : undefined);
});
$('btn-err-details').addEventListener('click', () => {
  const t = $('err-trace');
  t.hidden = !t.hidden;
  $('btn-err-details').setAttribute('aria-expanded', String(!t.hidden));
});
$('btn-err-fold').addEventListener('click', () => {
  const folded = $('errcard').classList.toggle('folded');
  $('btn-err-fold').setAttribute('aria-expanded', String(!folded));
  $('btn-err-fold').setAttribute('aria-label', folded ? 'Expand message' : 'Collapse message');
});

// ---- Seitenleiste -----------------------------------------------------------------------------------------------

document.querySelectorAll<HTMLButtonElement>('#rail [data-panel]').forEach((b) => b.addEventListener('click', () => {
  const p = b.dataset.panel as PanelName;
  showPanel(panel === p ? null : p);
}));
document.querySelectorAll<HTMLButtonElement>('.side-close').forEach((b) => b.addEventListener('click', () => showPanel(null)));
const toggleSide = () => showPanel(panel ? null : lastPanel);
$('btn-lay-side').addEventListener('click', toggleSide);
$('btn-lay-code').addEventListener('click', () => showCode(!codeOpen));
$('btn-lay-agent').addEventListener('click', () => setAgentCollapsed(!$('terminals').classList.contains('collapsed')));
$('btn-code-close').addEventListener('click', () => showCode(false));

// ---- Agent-Bereich ----------------------------------------------------------------------------------------------

function setAgentCollapsed(on: boolean): void {
  $('terminals').classList.toggle('collapsed', on);
  $('agent-strip').hidden = !on;
  $('split-right').hidden = on;
  if (!on) terminals.refit();
  store.set('soma.agentCollapsed', on ? '1' : '0');
  renderLayout();
}
$('btn-agent-expand').addEventListener('click', () => setAgentCollapsed(false));
terminals.onStripClick = () => setAgentCollapsed(false);

function renderAgentMenu(): void {
  $('agent-list').replaceChildren(...(agents.length ? agents : []).map((a) => {
    const d = el('span', { className: 'dot' });
    d.style.background = a.found ? 'var(--ok)' : 'transparent';
    if (!a.found) d.style.boxShadow = 'inset 0 0 0 1.5px var(--tx3)';
    const b = el('button', { className: 'mi', disabled: !a.found, title: a.found ? `Start ${a.command} in a new tab` : `${a.command} was not found in the PATH. Install the agent yourself, then it appears here.` },
      el('span', { className: 'noico' }, d), el('span', { textContent: a.label }), a.found ? null : el('span', { className: 'k', textContent: 'not installed' }));
    b.setAttribute('role', 'menuitem');
    b.addEventListener('click', () => { setAgentCollapsed(false); void terminals.add({ command: a.command, title: a.label }); });
    return b;
  }));
  if (!agents.length) $('agent-list').append(el('div', { className: 'mnote', textContent: 'Looking for agents …' }));
}
$('btn-term-add').addEventListener('click', () => { renderAgentMenu(); menus.toggle($('menu-agents'), $('btn-term-add')); });
$('btn-term-plain').addEventListener('click', () => void terminals.add({ title: 'Terminal' }));
$('btn-copy-path').addEventListener('click', () => void api.project.copyPath().then((r) => {
  toast(r.ok ? 'Path copied. Open it as the project folder in your agent app.' : r.error ?? 'The path could not be copied.', r.ok ? 'ok' : 'error');
}));

// ---- Trennleisten -----------------------------------------------------------------------------------------------

function splitter(id: string, target: () => HTMLElement, prop: () => string, sign: 1 | -1, min: number, max: () => number): void {
  const bar = $(id);
  bar.addEventListener('pointerdown', (down) => {
    const t = target();
    const start = down.clientX, startW = t.getBoundingClientRect().width;
    bar.classList.add('drag');
    bar.setPointerCapture(down.pointerId);
    const move = (e: PointerEvent) => t.style.setProperty(prop(), `${Math.max(min, Math.min(max(), startW + sign * (e.clientX - start)))}px`);
    const up = () => { bar.classList.remove('drag'); bar.removeEventListener('pointermove', move); bar.removeEventListener('pointerup', up); };
    bar.addEventListener('pointermove', move);
    bar.addEventListener('pointerup', up);
  });
}
splitter('split-side', () => $('side'), () => '--side', 1, 200, () => innerWidth * 0.4);
splitter('split-code', () => $('editor'), () => '--editor', 1, 280, () => innerWidth * 0.6);
splitter('split-right', () => $('terminals'), () => '--right', -1, 300, () => innerWidth - 560);

// ---- Startseite -------------------------------------------------------------------------------------------------

async function showStart(on: boolean): Promise<void> {
  $('start').hidden = !on;
  if (!on) return;
  menus.close();
  $('btn-start-close').hidden = $('start-close-sep').hidden = !project;
  $('start-close-name').textContent = project?.name ?? '';
  renderStartNote();
  renderTourCard();
  void renderUpdate();
  let list: ProjectListEntry[] = [];
  try { list = await api.project.list(); } catch { /* ohne Liste */ }
  list.sort((a, b) => b.modified - a.modified);
  // Ohne Modelle zeigen zwei große Karten den Weg, mit Modellen ist Zuletzt geöffnet der Hauptinhalt
  $('start-recent-wrap').hidden = !list.length;
  $('start-empty').hidden = $('start-tip').hidden = !!list.length;
  $('start-recent-count').textContent = String(list.length);
  ($('start-filter') as HTMLInputElement).value = '';
  $('start-recent').replaceChildren(...list.map((p) => {
    const th = el('div', { className: 'th' }, icon('cube', 36, 1.2));
    void api.project.thumb(p.id).then((url) => { if (url) th.replaceChildren(el('img', { src: url, alt: '' })); });
    const cur = p.id === project?.id;
    // Viele heißen „New model“: Ob es je gespeichert wurde, hilft beim Wiederfinden und beim Aufräumen
    const when = p.folder ? (p.missing ? '' : `changed ${fmtWhen(p.modified, true)}`) : p.saved ? `changed ${fmtWhen(p.modified, true)}` : fmtWhen(p.modified, true);
    // Ordner-Modus: Der Ordner steht im Tooltip, fehlt er, sagt die Karte es
    const title = cur ? 'Currently open' : p.folder ? `Open ${p.name}\nFolder: ${p.folder}` : `Open ${p.name}`;
    const card = el('button', { className: 'recent' + (cur ? ' cur' : ''), title },
      th, cur && el('span', { className: 'tag', textContent: 'Open' }),
      el('div', { className: 'meta' }, el('b', { textContent: p.name }),
        el('span', { className: 'sub' }, p.folder && el('span', { className: 'c3', textContent: 'Folder' }), when && el('span', { textContent: when }),
          !p.saved && el('span', { className: 'unsaved', textContent: 'never saved' }), p.missing && el('span', { className: 'unsaved', textContent: 'folder missing' }))));
    card.addEventListener('click', () => { if (!cur) void openProject(p.id); showStart(false); });
    const item = el('div', { className: 'recent-item' }, card);
    item.dataset.name = p.name.toLowerCase();
    if (cur) return item;
    // Entfernen (E69): Arbeitsordner in den Papierkorb, die Rückfrage im Hauptprozess sagt, was dabei verloren geht
    const rm = el('button', { className: 'recent-rm', title: p.folder ? `Remove “${p.name}” from the list. The folder stays.` : `Remove “${p.name}” from this computer`, ariaLabel: `Remove ${p.name}` }, icon('trash', 14));
    rm.addEventListener('click', () => void (async () => {
      const r = await api.project.remove(p.id).catch((e: unknown) => ({ removed: false, error: e instanceof Error ? e.message : String(e) }));
      if (r.error) toast(r.error, 'error');
      if (r.removed) { toast(p.folder ? `“${p.name}” removed from the list. The folder stays as it is.` : `“${p.name}” removed. The working folder is in the Recycle Bin.`, 'ok'); void showStart(true); }
    })());
    item.append(rm);
    return item;
  }), el('div', { id: 'start-nomatch', className: 'c3', textContent: 'No model matches the filter.', hidden: true }));
  if (!agents.length) await refreshAgents();
  renderStartAgents();
}

/** Agenten kompakt: gefundene zuerst, je eine Zeile mit Punkt wie im Agent-Menü. Jeder andere CLI-Agent geht auch (Zeile darunter). */
function renderStartAgents(): void {
  const list = [...agents.filter((a) => a.found), ...agents.filter((a) => !a.found)];
  $('start-agents-count').textContent = agents.length ? `${agents.filter((a) => a.found).length} of ${agents.length} found` : '';
  $('start-agents').replaceChildren(...list.map((a) => el('div', {
    className: 'agrow' + (a.found ? '' : ' off'),
    title: a.found ? `Found in the PATH as ${a.command}` : `${a.command} was not found in the PATH. Install the agent yourself, then it appears here.`,
  }, el('span', { className: 'dot' }), el('span', { className: 'nm', textContent: a.label }),
  a.found ? el('code', { textContent: a.command }) : el('span', { className: 'st', textContent: 'not installed' }))));
}

/** Sicherheitshinweis bei den Agenten: bis „Got it“ ausführlich, danach eine Zeile. */
function renderStartNote(): void {
  const seen = store.get('soma.noteSeen') === '1';
  $('start-note').hidden = seen;
  $('start-note-line').hidden = !seen;
}

/** Filter über die Namen der Karten. Escape im Feld leert es zuerst, erst das nächste Escape verlässt die Startseite. */
function filterStart(): void {
  const q = ($('start-filter') as HTMLInputElement).value.trim().toLowerCase();
  let shown = 0;
  for (const item of $('start-recent').querySelectorAll<HTMLElement>('.recent-item')) {
    item.hidden = !!q && !(item.dataset.name ?? '').includes(q);
    if (!item.hidden) shown++;
  }
  $('start-nomatch').hidden = shown > 0;
}
$('start-filter').addEventListener('input', filterStart);
$('start-filter').addEventListener('keydown', (e) => {
  const f = e.currentTarget as HTMLInputElement;
  if (e.key === 'Escape' && f.value) { e.preventDefault(); e.stopPropagation(); f.value = ''; filterStart(); }
});
// Escape führt zurück zum offenen Modell. Menüs, Rückfragen, Hilfe und Einstellungen nehmen Escape vorher für sich
window.addEventListener('keydown', (e) => {
  if (e.key !== 'Escape' || e.defaultPrevented || $('start').hidden || !project || help.isOpen || settings.isOpen) return;
  e.preventDefault();
  void showStart(false);
});
$('btn-start-close').addEventListener('click', () => showStart(false));
const startNew = () => { void doNew(); showStart(false); };
const startOpen = () => { void doOpen().then((ok) => { if (ok) showStart(false); }); };
$('start-new').addEventListener('click', startNew);
$('start-new-tpl').addEventListener('click', startNew);
$('start-empty-new').addEventListener('click', startNew);
$('start-open').addEventListener('click', startOpen);
$('start-empty-open').addEventListener('click', startOpen);
$('start-new-more').addEventListener('click', () => menus.toggle($('menu-start-new'), $('start-new-more'), 'right'));
$('start-new-cq').addEventListener('click', () => void doNewFromCadQuery());
$('start-empty-cq').addEventListener('click', () => void doNewFromCadQuery());
$('start-open-folder').addEventListener('click', () => { menus.close(); void doOpenFolder().then((ok) => { if (ok) showStart(false); }); });
$('btn-start-tip-help').addEventListener('click', () => void help.open());
/**
 * Pille „neue Version“ neben der Versionsnummer: neueste Version unter GitHub Releases (updates.ts, einmal je Sitzung). Ein
 * Klick öffnet die Seite im Browser, laden und installieren tut der Nutzer selbst. Bei aktuellem Stand keine Pille, klappt die
 * Prüfung nicht, eine leise. Ausgeschaltet (Settings › About) oder im Test ohne Adresse: keine.
 */
let updateInfo: UpdateInfo | null = null;
async function renderUpdate(): Promise<void> {
  const pill = $('start-update');
  if (!appSettings.settings.start.updateCheck) { pill.hidden = true; return; }
  if (!updateInfo) { pill.hidden = true; pill.className = 'uppill checking'; }
  try { updateInfo = await api.updates.check(); } catch (e) {
    updateInfo = { state: 'error', current: SOMA_VERSION, url: RELEASES_URL, error: e instanceof Error ? e.message : String(e) };
  }
  const u = updateInfo;
  if (!appSettings.settings.start.updateCheck || u.state === 'skipped') { pill.hidden = true; return; }
  const when = u.published ? ` on ${new Date(u.published).toLocaleDateString('en-GB', { day: 'numeric', month: 'short', year: 'numeric' })}` : '';
  const [ico, label, title] = u.state === 'newer'
    ? ['arrowup', `${u.latest} available`, `SOMA ${u.latest} was released${when}. You have ${u.current}. Opens the release page: download and install it there, your models stay.`]
    : u.state === 'current'
      ? ['okcirc', 'Up to date', `SOMA is up to date. ${u.current} is the latest release on GitHub.`]
      : ['alert', 'Update check failed', `Could not check for a new version. ${u.error ?? ''}`.trim()];
  pill.className = `uppill ${u.state}`;
  pill.title = title;
  pill.dataset.url = u.url;
  pill.replaceChildren(icon(ico, 12, 2.2), el('span', { textContent: label }));
  pill.hidden = u.state === 'current';
}
$('start-update').addEventListener('click', () => {
  const url = $('start-update').dataset.url ?? RELEASES_URL;
  void api.openUrl(url).then((r) => { if (!r.ok) toast(r.error ?? `${url} could not be opened.`, 'error'); });
});
const RELEASES_URL = 'https://github.com/Kai-Jungsthoefel/SOMA/releases';
$('btn-note-ok').addEventListener('click', () => { store.set('soma.noteSeen', '1'); renderStartNote(); });

// ---- Ereignisse vom Hauptprozess --------------------------------------------------------------------------------

api.project.onChanged((p) => void onProject(p));
let buildStarts = 0; // Prüfhilfe: Wie oft hat ein Build begonnen?
api.build.onStatus((s) => {
  if (s.state === 'building' && buildStatus.state !== 'building') buildStarts++;
  renderBuild(s);
  paramsPanel.setBuild(s);
  if (s.state === 'ok' && !s.stale) { void loadModel(); void refreshFiles(); void refreshViewLists(); }
  // Nach jedem Build (auch einem gescheiterten): Liste und Werte neu, der Build kennt die Parameter des Codes
  if (panel === 'params' && s.state !== 'building') void paramsPanel.refresh();
});
// Auch bei geschlossenem Code abgleichen: Offene Dateien können ungesicherte Eingaben enthalten
api.fs.onChanged(() => { textCache.clear(); void fileView.filesChanged(); void refreshFiles(); void code.refresh(); scheduleViewLists(); if (panel === 'params') void paramsPanel.refresh(); });
// Beim Beenden fragt der Hauptprozess, was im Editor ungespeichert ist, und lässt speichern oder verwerfen
api.fs.onEditorRequest(async (action) => {
  if (action === 'status') return { dirty: code.unsaved() };
  if (action === 'save') return { ok: (await code.saveAll()).ok };
  return { ok: await code.discardAll() };
});
// Rückfragen des Hauptprozesses (etwa „Save the model?“ beim Schließen) im Stil der App statt als weißer Dialog des Systems
api.dialog.onShow((o) => ask(o));
api.versions.onChanged(() => void versions.refresh());
api.anim.onChanged(() => { void animTool.refresh(); scheduleViewLists(); });
api.drawings.onChanged(() => { drawingsView()?.refresh(); scheduleViewLists(); });
api.render.onProgress((f) => animTool.progress(f));
// Bilder und Videos, die der Agent erzeugt hat: kurz Bescheid geben, ein Klick im Dateibaum öffnet sie
api.render.onNotice((n) => {
  if (!n.byAgent) return;
  if (n.ok) toast(`The agent created ${n.files.join(', ')}.`, 'info');
  void refreshFiles();
  scheduleViewLists();
});
// Ergebnisse von soma analyze melden sich nicht von selbst (.soma/results/ beobachtet niemand): ab und zu nachsehen
setInterval(() => { if (project && !document.hidden) void refreshViewLists(); }, 10000);
window.addEventListener('focus', () => scheduleViewLists());
api.project.onSaveState((st) => renderSaveState(st));
// Das Projekt kommt ausschließlich über das Ereignis (Startseite, Menü, im Testmodus öffnet es der Hauptprozess beim Start). Ein zweiter Weg würde alles doppelt aufbauen.

// Einstellungen der App (E81): Ein Modell, das schon offen ist, bekommt auch die Darstellung beim Öffnen
void api.settings.get().then((st) => { appSettings = st; applySettings(); applyDisplayDefaults(); renderTourCard(); }).catch(() => { /* es gelten die Vorgaben */ });

// ---- Tutorial (E94) ---------------------------------------------------------------------------------------------
// Erst hier angelegt: Seine Escape-Taste kommt nach Menüs, Messen und Markierung, die Escape zuerst für sich nutzen

const tourCtx: TourContext = {
  showPanel: (p) => showPanel(p),
  showCode: (on) => showCode(on),
  openCode: (f) => void openCode(f),
  expandAgent: () => setAgentCollapsed(false),
  // Die Liste nennt alle bekannten Agenten mit „found“. Leer heißt: Suche läuft noch
  agentsFound: () => (agents.length ? agents.filter((a) => a.found).map((a) => a.label) : null),
  selected: () => !!selection,
  measuring: () => measureTool.isActive,
  stopMeasure: () => { if (measureTool.isActive) measureTool.setActive(false); },
  marking: () => markup.active,
  closeEmptyMarkup: () => { if (markup.active && !markup.drawn) markup.close(); },
  // Läuft in jedem Frame: nur nachsehen, ob eine Zeile als geändert markiert ist (state() misst den ganzen Text)
  paramsChanged: () => !!document.querySelector('#params-list .prm.chg'),
};
/** Modell, zu dem die laufende Tour gehört. */
let tourProject: string | null = null;
const tour = new Tour({
  covered: () => !$('start').hidden || help.isOpen || settings.isOpen,
  // Durchlaufen blendet die Karte der Startseite aus (wie „Got it“), Überspringen nicht: Wer abbricht, findet sie dort wieder
  ended: (finished) => {
    if (finished) void hideTourCard();
    toast(finished ? 'That’s the basics. Help (F1) has the whole guide and can start the tutorial again.' : 'Tutorial ended. Help (F1) can start it again.', 'info');
  },
});

function renderTourCard(): void {
  $('start-tour').hidden = !appSettings.settings.start.tutorialCard;
}

/** Karte „New to SOMA?“ dauerhaft ausblenden (settings.json). Klappt das Schreiben nicht, bleibt sie für diese Sitzung weg. */
async function hideTourCard(): Promise<void> {
  $('start-tour').hidden = true;
  if (!appSettings.settings.start.tutorialCard) return;
  try {
    const r = await changeSettings({ start: { tutorialCard: false } });
    if (!r.ok) toast(r.error ?? 'The setting could not be saved.', 'error');
  } catch (e) { toast(`The setting could not be saved: ${e instanceof Error ? e.message : String(e)}`, 'error'); }
  $('start-tour').hidden = true;
}

/**
 * Tutorial starten: Es legt wie „New model“ ein neues Modell aus der Vorlage an, nur mit dem Namen „Tutorial“, und führt
 * daran durch die Oberfläche. Ein offenes Modell bleibt, wie es ist (unter Recent), nach einer Rückfrage, weil seine
 * Terminals dabei schließen. Bleibt das Tutorial-Modell unverändert, verschwindet es beim Wechsel wie jedes neue (E69).
 */
async function startTutorial(): Promise<void> {
  if (project) {
    const c = await api.dialog.choose({
      title: 'Tutorial', message: 'Start the tutorial with a new example model?',
      detail: `Your model “${project.name}” stays on the start page under Recent. Its terminals close.`, buttons: ['Start tutorial', 'Cancel'],
    });
    if (c !== 0) return;
  }
  if (!(await leaveEditor('Start tutorial'))) return;
  help.close();
  tour.stop(false, false);
  void showStart(false);
  let info: ProjectInfo;
  try { info = await api.project.create('tutorial'); } catch (e) {
    toast(`The example model could not be created: ${e instanceof Error ? e.message : String(e)}`, 'error');
    return;
  }
  tourProject = info.id;
  tour.start(tourSteps(tourCtx));
}
$('btn-tour-start').addEventListener('click', () => void startTutorial());
$('btn-tour-dismiss').addEventListener('click', () => void hideTourCard());
$('btn-help-tour').addEventListener('click', () => void startTutorial());
// Video-Tutorial auf YouTube: nur ein Link, der im Browser öffnet (kein eingebettetes Video: Netz und Datenschutz)
const TUTORIAL_VIDEO = 'https://www.youtube.com/watch?v=FJrgMl8ZGKI';
const openVideo = (): void => { void api.openUrl(TUTORIAL_VIDEO).then((r) => { if (!r.ok) toast(r.error ?? `${TUTORIAL_VIDEO} could not be opened.`, 'error'); }); };
$('btn-tour-video').addEventListener('click', openVideo);
$('btn-help-video').addEventListener('click', openVideo);

if (store.get('soma.agentCollapsed') === '1') setAgentCollapsed(true);
// Seitenleiste wie beim letzten Mal, beim ersten Start zu: Die Bauteile stehen im Baum im Viewer (E82)
{
  const side = store.get('soma.side');
  showPanel(side && PANELS.includes(side as PanelName) ? side as PanelName : null);
}
// Die App beginnt auf der Startseite (E69), der Hauptprozess öffnet kein Modell. Nur im Testmodus öffnet er gleich eins.
if (api.startsHome) void showStart(true);
// Erst jetzt steht, was der Nutzer sehen soll, die Startseite liegt schon über der Oberfläche
requestAnimationFrame(() => hideBoot());

// Prüfschnittstelle, nur im Testmodus
if (api.testMode) {
  (window as unknown as Record<string, unknown>).__t = {
    viewer, terminals,
    project: () => project,
    parts: () => viewer.partList(),
    partCount: () => viewer.partList().length,
    status: () => ({ state: buildStatus.state, text: $('status').textContent, detail: $('status-detail').textContent, viewerMsg: $('errcard').hidden ? $('viewer-msg').textContent : $('errcard').textContent }),
    info: () => ($('selcard').hidden ? '' : `${$('sel-name').textContent} · ${$('info').textContent} · ${$('code').querySelector('.ph')?.textContent ?? ''}`),
    codeHighlight: () => [...document.querySelectorAll('#code .cl.hl')].map((x) => x.textContent),
    treeNames: () => tree.names(),
    tree: () => tree.state(),
    treeOpen: (on: boolean) => tree.setOpen(on),
    picked: () => picked.map(partName),
    treeExpandAll: () => tree.expandAll(),
    termText: (id: number) => terminals.text(id),
    versions: () => versions.state(),
    saveState: () => saveState,
    toast: () => ({ text: $('toast').textContent, hidden: $('toast').hidden, error: $('toast').classList.contains('error') }),
    banner: () => ({ hidden: $('preview-banner').hidden, text: $('preview-banner').textContent }),
    fileView: () => ({ ...fileView.state(), banner: $('file-banner').hidden ? null : $('file-banner').textContent, frame: $('viewer').classList.contains('fileview') }),
    openFile: (rel: string) => fileView.open(rel),
    partSize: (name: string) => { const p = viewer.partList().find((x) => x.name === name); return p ? viewer.partSize(p.id) : null; },
    versionsUi: () => ({ restoreHidden: $('btn-restore').hidden, problem: $('vproblem').hidden ? '' : $('vproblem').textContent }),
    selectionText, errorText,
    markup: () => markup.state(),
    measure: () => measureTool.state(),
    mapBuild: () => map?.build ?? null,
    section: () => sectionTool.state(),
    explode: () => explodeTool.state(),
    busy: () => busy.state(),
    anim: () => animTool.state(),
    animSeek: (t: number) => animTool.testSeek(t),
    animRefresh: () => animTool.refresh(),
    result: () => resultTool.state(),
    resultRefresh: () => resultTool.refresh(),
    resultPin: (x: number, y: number) => resultTool.testPin(x, y),
    resultShow: (id: string) => resultTool.show(id),
    resultField: (f: 'value' | 'stress' | 'disp' | 'press') => resultTool.testField(f),
    resultDeform: (sc: number) => resultTool.testDeform(sc),
    analysis: () => analysisPanel.state(),
    analysisToggle: (key: string) => analysisPanel.testToggle(key),
    animShow: (id: string) => animTool.show(id),
    animPanel: () => animPanel.state(),
    drawings: () => drawingsView()?.state() ?? null,
    drawingsOpen: () => toggleDrawings(),
    drawingsScreen: (name: string, x: number, y: number) => drawingsView()?.screenOf(name, x, y) ?? null,
    drawingsGoTo: (name: string) => drawingsView()?.goTo(name),
    drawingsSelectNone: () => drawingsView()?.select(null),
    rail: () => ({ analysis: !$('nd-analysis').hidden, anim: !$('nd-anim').hidden, drawings: !$('nd-drawings').hidden, pressed: [...document.querySelectorAll<HTMLElement>('#rail [aria-pressed=true]')].map((b) => b.dataset.panel) }),
    dockCompact: () => $('dock').classList.contains('compact'),
    video: () => videoView.state(),
    videoOpen: (rel: string) => videoView.open(rel),
    videoSeek: (t: number) => videoView.testSeek(t),
    skills: () => skills.state(),
    params: () => paramsPanel.state(),
    paramsRefresh: () => paramsPanel.refresh(),
    pick: () => selection?.pick ?? null,
    markPixel: (x: number, y: number) => markup.pixel(x, y),
    markHandles: () => markup.handles(),
    markRelayout: () => markup.relayout(),
    markImage: (rel: string) => markImage(rel),
    insert: (text: string) => insertToAgent(text),
    showPanel: (p: PanelName | 'code' | null) => (p === 'code' ? showCode(true) : showPanel(p)),
    showCode,
    layout: () => ({ side: panel, code: codeOpen, agent: !$('terminals').classList.contains('collapsed') }),
    refreshViewLists: () => refreshViewLists(),
    openSkill: (id: string | null) => skills.openDetail(id),
    help: () => help.state(),
    openHelp: (title?: string) => help.open(title),
    closeHelp: () => help.close(),
    settings: () => settings.state(),
    openSettings: (id?: string) => settings.open(id),
    closeSettings: () => settings.close(),
    settingsSelect: (id: string | null) => settings.select(id),
    settingsType: (text: string) => settings.type(text),
    settingsSave: () => settings.save(),
    settingsShow: (sec: 'viewer' | 'keys' | 'skills' | 'storage' | 'about') => settings.open(undefined, sec),
    settingsPages: () => ({ viewer: viewerPage.state(), storage: storagePage.state(), about: aboutPage.state() }),
    appSettings: () => appSettings,
    storageRefresh: () => storagePage.refresh(),
    axes: () => viewer.axesState(),
    display: () => Object.fromEntries([...document.querySelectorAll<HTMLElement>('[data-display]')].map((b) => [b.dataset.display, b.getAttribute('aria-checked') === 'true'])),
    /** Export wie über das Menü (`sel`: das ausgewählte Bauteil), liefert das Ergebnis. */
    exportAs: (fmt: string, scope: 'all' | 'sel') => { exportScope = scope; return doExport(fmt, fmt.toUpperCase()); },
    /** „Everything as ZIP“ im Export-Menü (E79). */
    exportZip: () => doExportZip(),
    /** „As CadQuery script“ im Export-Menü und „New from CadQuery script“ (E100). */
    exportCadQuery: () => doExportCadQuery(),
    newFromCadQuery: () => doNewFromCadQuery(),
    cqBusy: () => ({ hidden: $('app-busy').hidden, text: $('app-busy').textContent }),
    showStart: (on: boolean) => showStart(on),
    tour: () => tour.state(),
    tourGo: (n: number) => tour.goTo(n),
    setAgentCollapsed,
    fileRows: () => [...document.querySelectorAll('#tab-files .frow .fn')].map((x) => x.textContent),
    revealFile: (rel: string) => files.reveal(rel, false),
    codeText: () => code.text(),
    openCode: (file: string) => openCode(file),
    buildStarts: () => buildStarts,
    editor: code.testApi(),
  };
}