Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice
TypeScript 3d-modeling3d-printing3d-printing-toolsagentagentic-aiai-cadcadcadqueryclaude-codecodexelectronfemllmmacdmakeropencodeparametric-designpythonsteptext-to-cad
App: Öffnen ohne Neubau, ein vorgewärmter Python-Prozess, Vorschau-Cache
Kai-Jungsthoefelbb08697d9070
diff --git a/app/src/main/build.ts b/app/src/main/build.tsindex 4c2bd5c..2aa26ed 100644--- a/app/src/main/build.ts+++ b/app/src/main/build.ts@@ -2,11 +2,18 @@ import { spawn, type ChildProcess } from 'node:child_process';import fs from 'node:fs';import path from 'node:path';import { EventEmitter } from 'node:events';+import { affectsBuild } from '../shared/editable';import type { BuildResult, BuildStatus } from '../shared/types';-import { pythonExe } from './paths';+import { pythonExe, warmDir } from './paths';+import { IGNORED_TOP } from './watcher';const DEBOUNCE_MS = 700;const TIMEOUT_MS = 5 * 60 * 1000;+/**+ * Fassung von model.glb, model.map.json und geometry/, gleich OUTPUT_FORMAT in python/soma/build.py. Nur ein Build mit+ * dieser Nummer wird beim Öffnen ohne Neubau gezeigt (currentBuild).+ */+export const OUTPUT_FORMAT = 1;/*** Startet `soma build` als eigenen Einmal-Prozess (E24) und haelt den Stand fest.@@ -18,14 +25,12 @@ const TIMEOUT_MS = 5 * 60 * 1000;* - Fehler sind Ergebnisse, keine Ausnahmen: der zuletzt gute Stand bleibt auf der Platte und im Viewer.** Python zu starten und cadquery zu laden dauert einige Sekunden, das Bauen selbst oft nur Bruchteile davon.- * Deshalb liegt immer ein vorgewärmter Prozess bereit (`soma build --wait`), der erst auf eine Startzeile hin baut.- * Jeder Build bleibt trotzdem ein eigener, frischer Prozess.+ * Deshalb nimmt jeder Build einen vorgewärmten Prozess aus dem Vorrat der App (startJob, unten).*/export class BuildManager extends EventEmitter {status: BuildStatus = { state: 'idle' };autoBuild = true;private proc: ChildProcess | null = null;- private spare: WarmProcess | null = null;private timer: NodeJS.Timeout | null = null;private rerun = false;private disposed = false;@@ -67,10 +72,7 @@ export class BuildManager extends EventEmitter {}const startedAt = Date.now();this.setStatus({ state: 'building', startedAt, reason, result: this.status.result });- // Ein schon beendeter Vorrat (abgestürzt, Python fehlt) wird nicht genommen: frisch starten, damit der Fehler sichtbar wird- let w = this.spare && !this.spare.ended ? this.spare : null;- if (!w) { this.spare?.child.kill(); w = spawnWarm(this.dir); }- this.spare = null;+ const w = startJob(this.dir, ['build', '--project', this.dir, '--json']);const { child } = w;this.proc = child;let done = false;@@ -83,7 +85,7 @@ export class BuildManager extends EventEmitter {clearTimeout(timeout);this.proc = null;if (this.disposed) return;- this.setStatus({ state: result.status === 'ok' ? 'ok' : 'error', result, seconds: (Date.now() - startedAt) / 1000 });+ this.setStatus({ state: result.status === 'ok' ? 'ok' : 'error', result, seconds: (Date.now() - startedAt) / 1000, builtAt: Date.now() });if (this.rerun) { this.rerun = false; this.start('Änderung während des Builds'); }};@@ -98,10 +100,18 @@ export class BuildManager extends EventEmitter {if (killedByTimeout) return finish(errorResult('Timeout', `Der Build wurde nach ${TIMEOUT_MS / 1000} s abgebrochen (Zeitlimit).`));finish(errorResult('NoResult', `Der Build lieferte kein Ergebnis (Exit-Code ${code}).\n${(w.err || w.out).slice(-2000)}`));};- try { child.stdin?.write('go\n'); } catch { /* Prozess schon weg: onClose meldet es */ }+ }- // Den nächsten Prozess schon jetzt vorwärmen, damit ein Folge-Build (Agent speichert erneut) nicht wieder wartet- if (!this.disposed) this.spare = spawnWarm(this.dir);+ /**+ * Den letzten Build übernehmen, ohne neu zu bauen (beim Öffnen, wenn er noch gilt, siehe currentBuild). Der Viewer lädt+ * dann gleich, was auf der Platte liegt. Läuft schon ein Build oder steht einer an, zählt dessen Ergebnis.+ */+ adopt(last: LastBuild): void {+ if (this.disposed || this.busy) return;+ const result: BuildResult = { status: 'ok', parts: last.parts, timings: last.timings, warnings: last.warnings };+ const seconds = typeof last.started === 'number' && typeof last.finished === 'number' ? Math.max(0, last.finished - last.started) : undefined;+ const builtAt = typeof last.finished === 'number' ? last.finished * 1000 : undefined;+ this.setStatus({ state: 'ok', result, reason: 'letzter Build', seconds, builtAt });}/** Läuft gerade ein Build oder steht einer an? */@@ -127,8 +137,6 @@ export class BuildManager extends EventEmitter {dispose(): void {this.disposed = true;this.cancel();- this.spare?.child.kill();- this.spare = null;this.removeAllListeners();}@@ -138,7 +146,42 @@ export class BuildManager extends EventEmitter {}}-/** Vorgewärmter `soma build --wait`. Ausgaben werden schon gesammelt, bevor ein Build ihn übernimmt. */+// ---- Vorgewärmte Python-Prozesse ------------------------------------------------------------------------------------++/**+ * Python starten und cadquery laden dauert rund 3 s. Deshalb liegt für die ganze App ein vorgewärmter Prozess bereit+ * (`soma warm`), unabhängig vom Projekt. Wer ihn nimmt (Build, Vorschau alter Stände, Export, Animationen, Auswertungen),+ * schickt ihm eine Zeile mit Ordner und Befehl, und gleich danach wärmt der nächste vor. So wartet auch der erste Build+ * nach dem Öffnen oder Anlegen eines Modells nicht auf Python. Jeder Auftrag bleibt ein eigener, frischer Prozess (E24).+ */+let spare: WarmProcess | null = null;+let warming = true;++/** Vorrat anlegen, falls keiner bereitliegt (beim Start der App und nach jeder Entnahme). */+export function warmUp(): void {+ if (warming && (!spare || spare.ended)) spare = spawnWarm();+}++/** Beim Beenden der App: Vorrat verwerfen und keinen neuen mehr anlegen. */+export function stopWarm(): void {+ warming = false;+ spare?.child.kill();+ spare = null;+}++/**+ * Auftrag an einen vorgewärmten Prozess. Ein schon beendeter Vorrat (abgestürzt, Python fehlt) wird nicht genommen:+ * frisch starten, damit der Fehler beim Auftrag sichtbar wird.+ */+function startJob(cwd: string, argv: string[]): WarmProcess {+ const w = spare && !spare.ended ? spare : spawnWarm();+ spare = null;+ warmUp();+ try { w.child.stdin?.end(JSON.stringify({ cwd, argv }) + '\n'); } catch { /* Prozess schon weg: onClose meldet es */ }+ return w;+}++/** Vorgewärmter `soma warm`. Ausgaben werden schon gesammelt, bevor ein Auftrag ihn übernimmt. */interface WarmProcess {child: ChildProcess;out: string;@@ -152,9 +195,11 @@ interface WarmProcess {onClose: ((code: number | null) => void) | null;}-function spawnWarm(dir: string): WarmProcess {- const child = spawn(pythonExe(), ['-m', 'soma', 'build', '--project', dir, '--json', '--wait'], {- cwd: dir, windowsHide: true,+function spawnWarm(): WarmProcess {+ const cwd = warmDir();+ try { fs.mkdirSync(cwd, { recursive: true }); } catch { /* dann scheitert der Start und meldet es */ }+ const child = spawn(pythonExe(), ['-m', 'soma', 'warm'], {+ cwd, windowsHide: true,env: { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8', PYTHONUNBUFFERED: '1' },});const w: WarmProcess = { child, out: '', err: '', lines: [], ended: false, error: null, onLine: null, onError: null, onClose: null };@@ -167,7 +212,7 @@ function spawnWarm(dir: string): WarmProcess {for (const l of parts) emitLine(w, l);});child.stderr?.on('data', (d: Buffer) => { w.err += d.toString('utf8'); });- // Ohne Listener würde ein Schreibfehler auf die Startzeile (Prozess schon weg) die App abstürzen lassen+ // Ohne Listener würde ein Schreibfehler auf die Auftragszeile (Prozess schon weg) die App abstürzen lassenchild.stdin?.on('error', () => { /* onClose meldet den Grund */ });child.on('error', (e) => { w.ended = true; w.error = e; w.onError?.(e); });child.on('close', (code) => {@@ -188,6 +233,18 @@ function errorResult(kind: string, message: string): BuildResult {return { status: 'error', error: { kind, message, file: null, line: null, traceback: '' } };}+/** Führt `python -m soma <args>` aus (z. B. glb für Vorschauen). Kein Wurf: das Ergebnis trägt den Fehler. */+export function runSoma(args: string[], cwd: string, timeoutMs = 120000): Promise<{ ok: boolean; out: string; err: string }> {+ return new Promise((resolve) => {+ const w = startJob(cwd, args);+ const timer = setTimeout(() => w.child.kill(), timeoutMs);+ w.onError = (e) => { clearTimeout(timer); resolve({ ok: false, out: w.out, err: e.message }); };+ w.onClose = (code) => { clearTimeout(timer); resolve({ ok: code === 0, out: w.out, err: w.err }); };+ });+}++// ---- Stand des letzten Builds ---------------------------------------------------------------------------------------+/** Neuester Änderungszeitpunkt von Einstiegspunkt, parts/ und inputs/ (Quelltext des Modells). */export function newestSourceMtime(dir: string): number {let newest = 0;@@ -207,22 +264,68 @@ export function newestSourceMtime(dir: string): number {return newest;}-/** Ist der Quelltext neuer als das letzte Build-Ergebnis (oder gibt es noch keines)? */+/**+ * Neuester Änderungszeitpunkt aller Dateien, deren Änderung bei offener App einen Build auslöst (dieselbe Regel wie der+ * Watcher). Weiter gefasst als newestSourceMtime: Was sich bei geschlossener App geändert hat, soll beim Öffnen auffallen.+ * Zu viele Dateien: Infinity, dann gilt der Build als veraltet (lieber einmal zu viel bauen).+ */+export function newestBuildInput(dir: string): number {+ let newest = 0, seen = 0;+ const walk = (d: string, rel: string, depth: number): boolean => {+ if (depth > 8) return true;+ let entries: fs.Dirent[];+ try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return true; }+ for (const e of entries) {+ if (++seen > 20000) return false;+ if (e.isSymbolicLink()) continue;+ const r = rel ? `${rel}/${e.name}` : e.name;+ if (e.isDirectory()) {+ if ((!rel && IGNORED_TOP.has(e.name)) || e.name === '__pycache__') continue;+ if (!walk(path.join(d, e.name), r, depth + 1)) return false;+ } else if (affectsBuild(r)) {+ try { newest = Math.max(newest, fs.statSync(path.join(d, e.name)).mtimeMs); } catch { /* verschwunden */ }+ }+ }+ return true;+ };+ return walk(dir, '', 0) ? newest : Infinity;+}++/** Inhalt von .soma/build.json (soma build schreibt sie bei jedem Lauf, auch bei Fehlern). */+export interface LastBuild extends BuildResult { format?: number; started?: number; finished?: number }++export function readLastBuild(dir: string): LastBuild | null {+ try {+ const b = JSON.parse(fs.readFileSync(path.join(dir, '.soma', 'build.json'), 'utf8')) as LastBuild;+ return b && typeof b === 'object' && (b.status === 'ok' || b.status === 'error') ? b : null;+ } catch { return null; }+}++/**+ * Ist der Quelltext neuer als das letzte Build-Ergebnis (oder gibt es noch keines)? Maßgeblich ist der Start des Builds:+ * Eine Änderung, während er lief, steckt womöglich nicht darin.+ */export function buildIsStale(dir: string): boolean {- try { return newestSourceMtime(dir) > fs.statSync(path.join(dir, '.soma', 'build.json')).mtimeMs; } catch { return true; }+ const last = readLastBuild(dir);+ if (!last) return true;+ let at = typeof last.started === 'number' ? last.started * 1000 : NaN;+ if (!Number.isFinite(at)) try { at = fs.statSync(path.join(dir, '.soma', 'build.json')).mtimeMs; } catch { return true; }+ return newestBuildInput(dir) > at;}-/** Führt `python -m soma <args>` aus (z. B. glb für Vorschauen). Kein Wurf: das Ergebnis trägt den Fehler. */-export function runSoma(args: string[], cwd: string, timeoutMs = 120000): Promise<{ ok: boolean; out: string; err: string }> {- return new Promise((resolve) => {- const child = spawn(pythonExe(), ['-m', 'soma', ...args], {- cwd, windowsHide: true, env: { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8' },- });- let out = '', err = '';- child.stdout.on('data', (d: Buffer) => { out += d.toString('utf8'); });- child.stderr.on('data', (d: Buffer) => { err += d.toString('utf8'); });- const timer = setTimeout(() => child.kill(), timeoutMs);- child.on('error', (e) => { clearTimeout(timer); resolve({ ok: false, out, err: e.message }); });- child.on('close', (code) => { clearTimeout(timer); resolve({ ok: code === 0, out, err }); });- });+/**+ * Der letzte Build, wenn er noch gilt: erfolgreich, in der Fassung dieser App (OUTPUT_FORMAT), mit allem, was Viewer und+ * Messen brauchen, und kein Quelltext neuer als sein Start. Sonst null, dann wird gebaut wie bisher.+ * Die Geometrie zum Messen hat die Kennung aus model.map.json im Namen. Fehlt sie, ist ein Build mittendrin abgebrochen.+ */+export function currentBuild(dir: string): LastBuild | null {+ const last = readLastBuild(dir);+ if (!last || last.status !== 'ok' || last.format !== OUTPUT_FORMAT) return null;+ const soma = path.join(dir, '.soma');+ try {+ const map = JSON.parse(fs.readFileSync(path.join(soma, 'model.map.json'), 'utf8')) as { build?: unknown };+ if (typeof map.build !== 'string' || !/^[0-9a-f]{32}$/.test(map.build)) return null;+ if (!fs.statSync(path.join(soma, 'model.glb')).isFile() || !fs.statSync(path.join(soma, 'geometry', `${map.build}.brep`)).isFile()) return null;+ } catch { return null; }+ return buildIsStale(dir) ? null : last;}diff --git a/app/src/main/main.ts b/app/src/main/main.tsindex 2fe291d..d700e77 100644--- a/app/src/main/main.ts+++ b/app/src/main/main.ts@@ -3,6 +3,7 @@ import fs from 'node:fs';import path from 'node:path';import { detectAgents } from './agents';import { bridgeEnv, startBridge, stopBridge } from './bridge';+import { stopWarm, warmUp } from './build';import { choose, setTestAnswers } from './dialogs';import { backupText, createEntry, entryPath, importInputs, listFiles, renameEntry, resolveInside, saveFeedbackImage, trashEntry, writeProjectText } from './files';import { ProjectController } from './projects';@@ -250,6 +251,8 @@ function createWindow(): void {// Erst die Verbindung für `soma render` (E58), dann das Fenster: Die Terminals bekommen Adresse und Schlüssel beim Anlegenapp.whenReady().then(async () => {+ // Python schon jetzt vorwärmen: Bis das Fenster steht und das letzte Modell offen ist, ist cadquery geladen (build.ts)+ warmUp();await startBridge(async (route, body) => {if (!controller) return { status: 503, body: { ok: false, error: 'Die App hat gerade kein Fenster.' } };if (route === 'render') return controller.renderForAgent(body);@@ -257,4 +260,4 @@ app.whenReady().then(async () => {});createWindow();});-app.on('window-all-closed', () => { stopBridge(); app.quit(); });+app.on('window-all-closed', () => { stopBridge(); stopWarm(); app.quit(); });diff --git a/app/src/main/paths.ts b/app/src/main/paths.tsindex 34c490f..6de1c13 100644--- a/app/src/main/paths.ts+++ b/app/src/main/paths.ts@@ -21,6 +21,11 @@ export const skillBackupsDir = (id: string) => path.join(backupsDir(), `${id}-skexport const previewsDir = () => path.join(userDataDir(), 'previews');/** Vorschaubilder für die Startseite (vom Viewer nach dem Laden des Modells, jederzeit neu erzeugbar). */export const thumbnailsDir = () => path.join(userDataDir(), 'thumbnails');+/**+ * Leerer Startordner der vorgewärmten Python-Prozesse (build.ts). Python setzt ihn vorn in den Suchpfad, also darf dort+ * nichts liegen, was Module überdeckt. Ein Projektordner geht nicht: Windows hielte ihn als aktuelles Verzeichnis fest.+ */+export const warmDir = () => path.join(userDataDir(), 'python-start');/** Vorlage fuer neue Projekte (liegt neben dem Programm, spaeter im Installationspaket). */export const templateDir = () => path.join(app.getAppPath(), 'resources', 'template');diff --git a/app/src/main/previews.ts b/app/src/main/previews.tsnew file mode 100644index 0000000..2238a50--- /dev/null+++ b/app/src/main/previews.ts@@ -0,0 +1,54 @@+import { randomUUID } from 'node:crypto';+import fs from 'node:fs';+import path from 'node:path';+import type { ModelMap } from '../shared/types';+import { readLastBuild, type LastBuild } from './build';++/** Eine GLB-Datei ist vollständig, wenn ihr Kopf passt und die angegebene Gesamtlänge der Dateigröße entspricht. */+function completeGlb(file: string): boolean {+ let fd: number | null = null;+ try {+ fd = fs.openSync(file, 'r');+ const head = Buffer.alloc(12);+ if (fs.readSync(fd, head, 0, 12, 0) !== 12 || head.readUInt32LE(0) !== 0x46546c67) return false;+ return head.readUInt32LE(8) === fs.fstatSync(fd).size;+ } catch { return false; } finally { if (fd !== null) fs.closeSync(fd); }+}++/**+ * Legt den aktuellen Build (`last`, aus .soma/) als Vorschau eines Standes im Verlauf nach `target`, in derselben Form wie+ * `soma glb` sie schreibt: model.glb, model.map.json und geometry/<build>.brep zum Messen. Der Aufrufer stellt sicher, dass+ * der Build genau diesen Stand zeigt (Arbeitsordner sauber, Build aktuell).+ *+ * Bleibt etwas nicht stehen, während kopiert wird (neuer Build, `stillValid` meldet false), wird die Kopie verworfen: eine+ * halbe Vorschau wäre schlimmer als keine, die entsteht dann wie bisher aus der STEP-Datei. Erst ein fertiger Ordner wird+ * umbenannt. Liefert true, wenn die Vorschau angelegt wurde.+ */+export async function storeBuildAsPreview(dir: string, target: string, last: LastBuild, stillValid: () => boolean): Promise<boolean> {+ const soma = path.join(dir, '.soma');+ const tmp = `${target}.tmp-${randomUUID()}`;+ try {+ const map = JSON.parse(await fs.promises.readFile(path.join(soma, 'model.map.json'), 'utf8')) as ModelMap;+ if (typeof map.build !== 'string' || !/^[0-9a-f]{32}$/.test(map.build) || !Array.isArray(map.parts)) return false;+ // Ohne Verweise auf den Code: In der Vorschau zeigt der Editor den aktuellen Code, dessen Zeilen passen womöglich nicht+ const parts = map.parts.map(({ file: _f, line: _l, end_line: _e, ...rest }) => rest);+ await fs.promises.mkdir(path.join(tmp, 'geometry'), { recursive: true });+ await fs.promises.copyFile(path.join(soma, 'model.glb'), path.join(tmp, 'model.glb'));+ await fs.promises.copyFile(path.join(soma, 'geometry', `${map.build}.brep`), path.join(tmp, 'geometry', `${map.build}.brep`));+ await fs.promises.writeFile(path.join(tmp, 'model.map.json'), JSON.stringify({ ...map, parts }, null, 1));+ // Inzwischen neu gebaut (auch vom Agenten im Terminal, den die App nicht mitbekommt)? Dann könnte die Kopie gemischt sein+ const now = readLastBuild(dir);+ const again = JSON.parse(await fs.promises.readFile(path.join(soma, 'model.map.json'), 'utf8')) as ModelMap;+ if (!stillValid() || now?.finished !== last.finished || again.build !== map.build || !completeGlb(path.join(tmp, 'model.glb'))) {+ await fs.promises.rm(tmp, { recursive: true, force: true });+ return false;+ }+ await fs.promises.mkdir(path.dirname(target), { recursive: true });+ await fs.promises.rename(tmp, target);+ return true;+ } catch {+ // Gibt es die Vorschau schon (gleichzeitig angelegt) oder fehlt eine Datei: nichts zu tun, ohne Cache geht es wie bisher+ await fs.promises.rm(tmp, { recursive: true, force: true }).catch(() => {});+ return false;+ }+}diff --git a/app/src/main/projects.ts b/app/src/main/projects.tsindex cbb53c3..859d7da 100644--- a/app/src/main/projects.ts+++ b/app/src/main/projects.ts@@ -8,12 +8,13 @@ import type {} from '../shared/types';import { affectsAnimation } from '../shared/editable';import { AnimBuilder, listResults, readAnimList, rerunResult, samePath } from './animations';-import { BuildManager, buildIsStale, newestSourceMtime, runSoma } from './build';+import { BuildManager, buildIsStale, currentBuild, newestSourceMtime, runSoma } from './build';import { checkRequest, RenderService, type RenderRequest } from './render';import { choose, chooseExportTarget, choosePath, documentsDir } from './dialogs';-import { GitRepo } from './git';+import { GitRepo, type GitStatus } from './git';import { MeasureService } from './measure';import { previewsDir, skillBackupsDir, skillsDir } from './paths';+import { storeBuildAsPreview } from './previews';import {agentsEntries, bundledSkill, checkValue, cleanValues, copySkill, isSkillId, isSkillMode, listSkills, modeOf, removeSkill, withMode, writeAgentsList, type SkillValues,} from './skills';@@ -39,6 +40,8 @@ interface Session {stopWatch: () => void;poll: NodeJS.Timeout;signature: string;+ /** Legt gerade den Build als Vorschau des letzten Commits ab (cachePreview). */+ caching?: boolean;}const POLL_MS = 2000;@@ -88,17 +91,24 @@ export class ProjectController {const terminals = new TerminalManager(this.wc, dir);const git = new GitRepo(dir);void git.ensureIgnored(); // ältere Projekte: Zwischenergebnisse auch aus den Commits des Agenten heraushalten- builds.on('status', (st) => this.send('build:status', st));const anims = new AnimBuilder(dir, () => this.send('anim:changed'));const stopWatch = watchProject(dir, (rel) => builds.sourceChanged(rel ? path.join(dir, rel) : null), () => this.send('fs:changed'),(rel) => this.animFileChanged(rel));const session: Session = { id, dir, builds, terminals, git, measure: new MeasureService(dir), anims, stopWatch, signature: '', poll: setInterval(() => void this.pollGit(), POLL_MS) };this.session = session;+ builds.on('status', (st) => {+ this.send('build:status', st);+ if (st.state === 'ok' && !st.stale) void this.cachePreview(session);+ });setLastProject(id);- // Erster Build direkt beim Öffnen, damit der Viewer nicht leer ist (der Nutzer kann Auto-Build danach abschalten).- builds.start('Projekt geöffnet');+ // Gilt der letzte Build noch (seit seinem Start nichts geändert), zeigt der Viewer ihn gleich, statt neu zu bauen. Sonst+ // erster Build direkt beim Öffnen, damit der Viewer nicht leer ist (der Nutzer kann Auto-Build danach abschalten).+ const last = currentBuild(dir);+ if (!last) builds.start('Projekt geöffnet');const info = this.info();this.send('project:changed', info);+ // Erst nach project:changed: Das Fenster räumt beim Projektwechsel den Viewer leer und lädt danach das Modell+ if (last) builds.adopt(last);return info;}@@ -119,9 +129,30 @@ export class ProjectController {s.signature = sig;this.send('versions:changed');this.send('save:state', await this.saveState());+ if (hasRepo) void this.cachePreview(s, st as GitStatus);} catch { /* nächster Durchlauf */ }}+ /**+ * Vorschau-Cache für die Zeitleiste: Ist der Arbeitsordner sauber (alles wie im letzten Commit) und gilt der letzte Build,+ * zeigt das aktuelle Modell genau diesen Commit. Dann wird es als dessen Vorschau abgelegt, und ein Sprung zurück muss die+ * STEP-Datei nicht wieder einlesen und vernetzen (bei großen Modellen rund 10 s). Ausgelöst von neuen Commits (auch des+ * Agenten) und fertigen Builds. Was nicht passt, bleibt einfach ohne Cache.+ */+ private async cachePreview(s: Session, known?: GitStatus): Promise<void> {+ if (this.session !== s || s.caching || s.builds.busy) return;+ s.caching = true;+ try {+ const st = known ?? (fs.existsSync(path.join(s.dir, '.git')) ? await s.git.status() : null);+ if (!st || st.dirty || !st.head || this.session !== s || s.builds.busy) return;+ const target = path.join(previewsDir(), s.id, st.head);+ if (fs.existsSync(path.join(target, 'model.glb')) && fs.existsSync(path.join(target, 'geometry'))) return;+ const last = currentBuild(s.dir);+ if (!last) return;+ await storeBuildAsPreview(s.dir, target, last, () => this.session === s && !s.builds.busy);+ } catch { /* ohne Cache: Die Vorschau entsteht beim Ansehen aus der STEP-Datei */ } finally { s.caching = false; }+ }+// ---- Speicherstand ----------------------------------------------------------------------------------------------async saveState(): Promise<SaveState> {diff --git a/app/src/main/watcher.ts b/app/src/main/watcher.tsindex f9a888c..3c6a19f 100644--- a/app/src/main/watcher.ts+++ b/app/src/main/watcher.ts@@ -2,7 +2,7 @@ import fs from 'node:fs';import { affectsAnimation, affectsBuild } from '../shared/editable';/** Ordner, die nie einen Build oder eine Neuanzeige der Dateiliste ausloesen (Ausgaben wuerden sich sonst selbst anstossen). */-const IGNORED_TOP = new Set(['.git', '.soma', 'output', 'exports', '__pycache__', 'node_modules', '.venv', 'venv', 'env']);+export const IGNORED_TOP = new Set(['.git', '.soma', 'output', 'exports', '__pycache__', 'node_modules', '.venv', 'venv', 'env']);const topSegment = (rel: string) => rel.split(/[\\/]/)[0] ?? '';/** Markierungen (E16) stehen im Dateibaum: Änderungen dort frischen die Liste auf, bauen aber nie. */diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.tsindex 1fc1759..5054d19 100644--- a/app/src/renderer/main.ts+++ b/app/src/renderer/main.ts@@ -588,7 +588,7 @@ function openGroupMenu(ids: string[], name: string, x: number, y: number): voidfunction renderBuild(s: BuildStatus): void {buildStatus = s;- if (s.state === 'ok') lastOkAt = Date.now();+ 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);@@ -692,7 +692,10 @@ 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) {+ 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.+ if (!res && restored && buildStatus.state === 'building') return;if (!res) { await loadModel(); return; }animTool.setActive(false);resultTool.setActive(false);diff --git a/app/src/renderer/versions.ts b/app/src/renderer/versions.tsindex 07d2619..9c5bd41 100644--- a/app/src/renderer/versions.ts+++ b/app/src/renderer/versions.ts@@ -15,8 +15,11 @@ interface Ui {}interface Hooks {- /** `res` = Vorschau eines alten Standes, `null` = zurück zum Arbeitsstand. */- show(res: PreviewResult | null): Promise<void>;+ /**+ * `res` = Vorschau eines alten Standes, `null` = zurück zum Arbeitsstand. `restored`: Der Stand in der Vorschau wurde eben+ * wiederhergestellt, sie zeigt also schon den neuen Arbeitsstand.+ */+ show(res: PreviewResult | null, restored?: boolean): Promise<void>;toast(text: string, kind: 'ok' | 'info' | 'error'): void;/** Vor dem Wiederherstellen: ungespeicherte Eingaben im Editor klären. false = abbrechen. */beforeRestore(): Promise<boolean>;@@ -115,7 +118,7 @@ export class VersionsBar {this.hooks.toast(r.commit ? 'Stand wiederhergestellt und als neuer Stand im Verlauf abgelegt.' : 'Dieser Stand war schon der aktuelle.', 'ok');this.previewHash = null;await this.refresh();- await this.hooks.show(null);+ await this.hooks.show(null, true);}private render(): void {diff --git a/app/src/shared/types.ts b/app/src/shared/types.tsindex 57a0aa5..c70553a 100644--- a/app/src/shared/types.ts+++ b/app/src/shared/types.ts@@ -26,6 +26,8 @@ export interface BuildStatus {state: BuildState; result?: BuildResult; startedAt?: number; queued?: boolean; reason?: string;/** Gesamtdauer des letzten Builds in Sekunden, vom Start bis zum Ergebnis (inkl. Python-Start). */seconds?: number;+ /** Zeitpunkt des Ergebnisses (ms). Hat die App beim Öffnen den letzten Build übernommen, liegt er vor dem Öffnen. */+ builtAt?: number;/** Auto-Build ist aus und der Quelltext hat sich seit dem letzten Build geändert. */stale?: boolean;}diff --git a/app/test/harness.mjs b/app/test/harness.mjsindex 75e8a70..19640c0 100644--- a/app/test/harness.mjs+++ b/app/test/harness.mjs@@ -1,6 +1,7 @@// Gemeinsame Testhilfe: startet die echte Electron-App mit isolierten App-Daten und steuert sie per CDP.import { spawn, spawnSync } from 'node:child_process';import fs from 'node:fs';+import net from 'node:net';import os from 'node:os';import path from 'node:path';import { electronExe } from '../scripts/electron-local.mjs';@@ -9,6 +10,13 @@ import { connectPage } from './cdp.mjs';export const APP = path.resolve(import.meta.dirname, '..');export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));+/** Ist der Port frei? Probeweise belegen, wie Electron es für den Debug-Port tut. */+const portFree = (port) => new Promise((resolve) => {+ const srv = net.createServer();+ srv.once('error', () => resolve(false));+ srv.listen(port, '127.0.0.1', () => srv.close(() => resolve(true)));+});+/*** Startet die App. Standard: Fenster unsichtbar (SMOKE_VISIBLE=1 zeigt es), eigener App-Daten-Ordner,* Watchdog (hängt etwas, wird alles hart beendet). `userData` erlaubt einen Neustart mit denselben Daten.@@ -18,6 +26,9 @@ export async function startApp({ port = Number(process.env.SOMA_TEST_PORT) || 93const mode = process.env.SMOKE_VISIBLE;const visible = mode === '1';const ud = userData ?? fs.mkdtempSync(path.join(os.tmpdir(), `soma-${name}-`));+ // Nach einem harten Beenden kann ein Kindprozess der alten App den Debug-Port noch kurz halten (geerbter Socket):+ // warten, sonst startet Electron ohne Debug-Port und der Test findet kein Fenster+ for (const t0 = Date.now(); !(await portFree(port)) && Date.now() - t0 < 30000;) await sleep(300);const child = spawn(electronExe(APP), ['.', `--remote-debugging-port=${port}`], {cwd: APP, env: { ...process.env, SOMA_USER_DATA: ud, SOMA_TEST: '1', SOMA_HIDDEN: visible ? '0' : mode === 'offscreen' ? 'offscreen' : '1' }, stdio: ['ignore', 'pipe', 'pipe'],});@@ -25,8 +36,24 @@ export async function startApp({ port = Number(process.env.SOMA_TEST_PORT) || 93child.stdout.on('data', (d) => { log += d; });child.stderr.on('data', (d) => { log += d; });const kill = () => {- if (process.platform === 'win32') spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true });- else child.kill('SIGKILL');+ if (process.platform !== 'win32') { child.kill('SIGKILL'); return; }+ if (spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true }).status === 0) return;+ // taskkill /T lässt den ganzen Baum stehen, sobald sich ein Kind nicht beenden lässt. Das passiert mit den kurzlebigen+ // Hilfsprozessen von node-pty (entstehen beim Schließen eines Terminals). Und unter Last braucht der Hauptprozess nach+ // dem Beenden teils viele Sekunden, bis er wirklich weg ist (etwa wenn App und Git auf einem Netzlaufwerk liegen). Solange hält er+ // Debug-Port und App-Daten fest, ein Neustart mit denselben Daten fände kein Fenster. Deshalb: Kinder einzeln beenden+ // (sie können den Port geerbt haben), dann den Hauptprozess, warten, bis er weg ist, und noch einmal die Kinder.+ const killKids = () => {+ const kids = spawnSync('powershell', ['-NoProfile', '-Command', `(Get-CimInstance Win32_Process -Filter "ParentProcessId=${child.pid}").ProcessId`], { encoding: 'utf8', windowsHide: true }).stdout ?? '';+ for (const pid of kids.split(/\s+/).filter((p) => /^\d+$/.test(p))) spawnSync('taskkill', ['/PID', pid, '/T', '/F'], { windowsHide: true });+ };+ killKids();+ const alive = () => new RegExp(`\\b${child.pid}\\b`).test(spawnSync('tasklist', ['/FI', `PID eq ${child.pid}`, '/NH'], { encoding: 'utf8', windowsHide: true }).stdout ?? '');+ for (const t0 = Date.now(); alive() && Date.now() - t0 < 60000;) {+ spawnSync('taskkill', ['/PID', String(child.pid), '/F'], { windowsHide: true });+ Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 500);+ }+ killKids();};const dog = setTimeout(() => { console.log('ABBRUCH: Watchdog'); kill(); process.exit(1); }, watchdogMs);dog.unref();diff --git a/app/test/unit.mjs b/app/test/unit.mjsindex abc5d6f..efee0b4 100644--- a/app/test/unit.mjs+++ b/app/test/unit.mjs@@ -264,6 +264,64 @@ try {} finally {fs.rmSync(gz, { force: true });}++ // Letzter Build beim Öffnen übernehmen (statt neu zu bauen) und als Vorschau eines Commits ablegen. paths.ts braucht+ // electron nur in Funktionen, die hier nicht laufen: ersetzt durch eine leere Attrappe.+ const bp = path.join(tmp, 'buildstate.mjs');+ const noElectron = { name: 'ohne-electron', setup(b) {+ b.onResolve({ filter: /^electron$/ }, () => ({ path: 'electron', namespace: 'attrappe' }));+ b.onLoad({ filter: /.*/, namespace: 'attrappe' }, () => ({ contents: 'export const app = undefined;', loader: 'js' }));+ } };+ await build({ stdin: { contents: "export { newestBuildInput, buildIsStale, currentBuild, OUTPUT_FORMAT } from './src/main/build.ts'; export { storeBuildAsPreview } from './src/main/previews.ts';", resolveDir: APP, loader: 'ts' },+ outfile: bp, bundle: true, platform: 'node', format: 'esm', plugins: [noElectron], logLevel: 'silent' });+ const { newestBuildInput, buildIsStale, currentBuild, OUTPUT_FORMAT, storeBuildAsPreview } = await import(pathToFileURL(bp).href);+ const bd = path.join(tmp, 'gebaut');+ const put2 = (rel, data, secs) => {+ const f = path.join(bd, rel);+ fs.mkdirSync(path.dirname(f), { recursive: true });+ fs.writeFileSync(f, data);+ if (secs != null) fs.utimesSync(f, secs, secs);+ };+ const T = 1_700_000_000; // Sekunden+ put2('model.py', 'x', T); put2('parts/a.py', 'x', T + 10);+ // Neuer, aber ohne Einfluss auf das Modell: Notizen, Ausgaben, App-Daten, Animationen, Caches+ put2('NOTES.md', 'x', T + 500); put2('output/model.step', 'x', T + 500); put2('.soma/x.py', 'x', T + 500);+ put2('animations/a.py', 'x', T + 500); put2('parts/__pycache__/a.py', 'x', T + 500);+ check('Quellen des Modells: .py überall und inputs/, nicht Notizen, Ausgaben, .soma, Animationen', newestBuildInput(bd) === (T + 10) * 1000, String(newestBuildInput(bd)));+ put2('lib/tief/hilfe.py', 'x', T + 20); put2('inputs/teil.step', 'x', T + 30);+ check('Auch Hilfsmodule außerhalb von parts/ und Dateien in inputs/ zählen', newestBuildInput(bd) === (T + 30) * 1000);++ const BID = 'ab'.repeat(16);+ const glb = Buffer.alloc(20);+ glb.writeUInt32LE(0x46546c67, 0); glb.writeUInt32LE(2, 4); glb.writeUInt32LE(20, 8);+ const map = { version: 0, build: BID, parts: [{ id: '0:Body', name: 'Body', step_name: 'Body', role: 'part', file: 'model.py', line: 3, end_line: 4 }] };+ const writeBuild = (b) => put2('.soma/build.json', JSON.stringify({ status: 'ok', format: OUTPUT_FORMAT, started: T + 40, finished: T + 45, parts: [], ...b }));+ writeBuild({});+ put2('.soma/model.glb', glb); put2('.soma/model.map.json', JSON.stringify(map)); put2(`.soma/geometry/${BID}.brep`, 'BREP');+ check('Build nach der letzten Änderung, alles da: gilt noch (kein Neubau beim Öffnen)', !buildIsStale(bd) && currentBuild(bd)?.finished === T + 45);+ writeBuild({ started: T + 25 });+ check('Quelle neuer als der Start des Builds (Änderung während des Builds): veraltet', buildIsStale(bd) && currentBuild(bd) === null);+ writeBuild({ format: undefined });+ check('build.json ohne Fassung (ältere soma): neu bauen', currentBuild(bd) === null);+ writeBuild({ status: 'error' });+ check('Letzter Build fehlgeschlagen: neu bauen', currentBuild(bd) === null);+ writeBuild({});+ fs.renameSync(path.join(bd, '.soma', 'geometry', `${BID}.brep`), path.join(bd, '.soma', 'geometry', 'weg.brep'));+ check('Geometrie zum Messen fehlt (Build mittendrin abgebrochen): neu bauen', currentBuild(bd) === null);+ fs.renameSync(path.join(bd, '.soma', 'geometry', 'weg.brep'), path.join(bd, '.soma', 'geometry', `${BID}.brep`));++ const last = currentBuild(bd);+ const target = path.join(tmp, 'previews', 'p', 'c1');+ check('Vorschau aus dem Build ablegen', await storeBuildAsPreview(bd, target, last, () => true));+ const pm = JSON.parse(fs.readFileSync(path.join(target, 'model.map.json'), 'utf8'));+ check('Vorschau: GLB und Geometrie kopiert, Mapping ohne Code-Verweise, Rolle bleibt', fs.readFileSync(path.join(target, 'model.glb')).equals(glb)+ && fs.readFileSync(path.join(target, 'geometry', `${BID}.brep`), 'utf8') === 'BREP' && pm.build === BID && pm.parts[0].role === 'part'+ && !('file' in pm.parts[0]) && !('line' in pm.parts[0]) && !('end_line' in pm.parts[0]), JSON.stringify(pm.parts[0]));+ const target2 = path.join(tmp, 'previews', 'p', 'c2');+ check('Inzwischen neu gebaut (stillValid false): keine Vorschau', !(await storeBuildAsPreview(bd, target2, last, () => false)) && !fs.existsSync(target2));+ put2('.soma/model.glb', glb.subarray(0, 16));+ check('Abgeschnittene GLB (Build schreibt gerade): keine Vorschau', !(await storeBuildAsPreview(bd, target2, last, () => true)) && !fs.existsSync(target2));+ check('Keine halben Ordner übrig', fs.readdirSync(path.join(tmp, 'previews', 'p')).join(',') === 'c1');} catch (e) {console.log('ABBRUCH:', e.message);t.fail();diff --git a/app/test/versions.mjs b/app/test/versions.mjsindex 4420a47..b3596dd 100644--- a/app/test/versions.mjs+++ b/app/test/versions.mjs@@ -37,6 +37,9 @@ try {const zipPath = path.join(workDir, 'Testmodell.zip');const versions = () => ev(() => window.__t.versions());const saveState = () => ev(() => window.__t.saveState());+ // Vorschau-Cache eines Standes (previews/<Projekt>/<Commit>) und Warten auf Dateien außerhalb des Fensters+ const cached = (hash) => path.join(ud, 'previews', proj.id, hash);+ const until = async (fn, ms = 15000) => { const t0 = Date.now(); while (!fn() && Date.now() - t0 < ms) await sleep(200); return fn(); };// ---- 1) Neues Projekt hat einen Git-Verlauf, mitgeliefertes Git im Terminal ----await waitFor('Verlauf geladen', () => window.__t.versions().count === 1);@@ -59,6 +62,12 @@ try {await type('git add -A; git commit -q -m "Laenge auf 80"');await waitFor('zweiter Stand im Verlauf', () => window.__t.versions().count === 2, 20000);check('Commit des Agenten erscheint in der Verlaufsleiste', (await versions()).subjects.includes('Laenge auf 80'));+ // Sauberer Arbeitsordner und aktueller Build: Der Build zeigt genau den neuen Commit und wird dessen Vorschau+ const head2 = await g('rev-parse', 'HEAD');+ check('Neuer Commit bei sauberem Ordner: Build liegt gleich als Vorschau bereit', await until(() => fs.existsSync(path.join(cached(head2), 'model.glb'))));+ const cmap = fs.existsSync(path.join(cached(head2), 'model.map.json')) ? JSON.parse(fs.readFileSync(path.join(cached(head2), 'model.map.json'), 'utf8')) : { parts: [] };+ check('Vorschau aus dem Build: Rollen bleiben, ohne Code-Verweise, mit Geometrie zum Messen', cmap.parts.length === 2+ && cmap.parts.every((x) => x.role !== 'basic' && !('file' in x) && !('line' in x)) && fs.existsSync(path.join(cached(head2), 'geometry', `${cmap.build}.brep`)));const kinds = (await versions()).byApp;check('Leiste unterscheidet App-Stand (Start) und Agenten-Stand', kinds[0] === true && kinds[1] === false, JSON.stringify(kinds));check('App-Commits tragen den Trailer „Erstellt-von: SOMA"', (await g('log', '--format=%(trailers:key=Erstellt-von,valueonly)', 'HEAD~1')).includes('SOMA'));@@ -89,10 +98,15 @@ try {// ---- 4) Vorschau alter Stände ----const first = await g('rev-parse', 'HEAD~2');+ check('Erster Stand liegt schon als Vorschau bereit (beim Anlegen abgelegt)', fs.existsSync(path.join(cached(first), 'model.glb')));+ // Ohne Cache entsteht die Vorschau wie bisher aus der STEP-Datei des Standes+ fs.rmSync(cached(first), { recursive: true, force: true });await ev(() => document.querySelectorAll('#vdots .vdot')[0].click());await waitFor('Vorschau aktiv', () => !!window.__t.versions().previewing, 60000);await waitFor('Vorschau geladen', () => window.__t.partCount() === 2 && !window.__t.banner().hidden);check('Vorschau des ersten Standes: Body ist 60 mm lang (Arbeitsstand: 80)', (await ev(() => window.__t.partSize('Body')))[0] === 60);+ const smap = JSON.parse(fs.readFileSync(path.join(cached(first), 'model.map.json'), 'utf8'));+ check('Ohne Cache: Vorschau aus der STEP-Datei des Standes erzeugt (Basismodus)', smap.parts.length === 2 && smap.parts.every((x) => x.role === 'basic'));const bn = (await ev(() => window.__t.banner())).text.replace(/\s+/g, ' ').trim();check('Banner zeigt „Vorschau · Stand 1 von …, nur ansehen"', bn.includes('Vorschau · Stand 1 von') && bn.includes('nur ansehen') && bn.includes('Arbeitsstand bleibt unverändert'), bn.slice(0, 60));check('Viewer hat den Vorschau-Rahmen', await ev(() => document.getElementById('viewer').classList.contains('preview')));@@ -119,6 +133,8 @@ try {await app.answers([0]);await domClick('btn-restore');await waitFor('wiederhergestellt', () => !window.__t.versions().previewing && window.__t.versions().subjects.some((s) => s.startsWith('Stand wiederhergestellt')), 60000);+ // Vorher lud die Ansicht hier den vorherigen Build (Body 80) und zeigte ihn, bis der neue fertig war+ check('Gleich nach dem Wiederherstellen ist der wiederhergestellte Stand zu sehen (Body 60, nicht 80)', (await ev(() => window.__t.partSize('Body')))[0] === 60);check('Wiederherstellen legt einen NEUEN Commit an', (await g('log', '-1', '--format=%s')).startsWith('Stand wiederhergestellt: Neues Modell angelegt'));check('Verlauf blieb vollständig (alter Startcommit unverändert vorhanden)', (await g('cat-file', '-t', first)) === 'commit' && (await g('rev-list', '--count', 'HEAD')) > commitsBefore);check('Dateien sind zurück: model.py mit 60, Notiz-Wunsch entfernt', fs.readFileSync(modelPy, 'utf8').includes('LENGTH = 60.0') && !fs.readFileSync(path.join(dir, 'NOTES.md'), 'utf8').includes('Wunsch'));@@ -164,8 +180,10 @@ try {check('Bisheriger Arbeitsordner liegt gesichert in workspace-backups/', backups.length === 1 && fs.readFileSync(path.join(ud, 'workspace-backups', backups[0], 'NOTES.md'), 'utf8').includes('LOKALE ÄNDERUNG'));const logBefore = await g('log', '--format=%s');// C) anderer Rechner: Arbeitsordner existiert nicht -> entpacken+ const startsBefore = await ev(() => window.__t.buildStarts());await domClick('btn-new');- await waitFor('zweites Projekt', (id) => window.__t.project().id !== id && window.__t.status().state === 'ok', 90000, proj.id);+ await waitFor('zweites Projekt', (id) => window.__t.project().id !== id && window.__t.status().state === 'ok' && window.__t.partCount() === 2, 90000, proj.id);+ check('Neues Modell: gebaut wird beim Anlegen, beim Öffnen nicht noch einmal', (await ev(() => window.__t.buildStarts())) === startsBefore);await rmRetry(dir);fs.rmSync(path.join(ud, 'projects', `${proj.id}.json`), { force: true });await app.answers([zipPath]);@@ -204,7 +222,12 @@ try {app = await startApp({ name: 'versions', userData: ud2 });await app.waitFor('Projekt wieder da', () => !!window.__t && !!window.__t.project() && window.__t.status().state === 'ok');check('Nach hartem Beenden öffnet die App dasselbe Projekt wieder', (await app.ev(() => window.__t.project().id)) === proj.id);- check('Die ungespeicherte Änderung ist noch da und als ungespeichert markiert', fs.readFileSync(path.join(dir, 'NOTES.md'), 'utf8').includes('vor dem Absturz') && (await app.ev(() => window.__t.saveState().unsaved)));+ await app.waitFor('Modell sichtbar', () => window.__t.partCount() === 2, 20000).catch(() => {});+ check('Modell unverändert seit dem letzten Build: Es ist gleich zu sehen, ohne Neubau', (await app.ev(() => window.__t.partCount())) === 2+ && (await app.ev(() => window.__t.buildStarts())) === 0, `Builds: ${await app.ev(() => window.__t.buildStarts())}`);+ // Ohne Neubau ist das Modell da, bevor das Fenster den Speicherstand abgefragt hat+ await app.waitFor('Speicherstand', () => !!window.__t.saveState(), 20000).catch(() => {});+ check('Die ungespeicherte Änderung ist noch da und als ungespeichert markiert', fs.readFileSync(path.join(dir, 'NOTES.md'), 'utf8').includes('vor dem Absturz') && (await app.ev(() => window.__t.saveState()?.unsaved)));const relevant = page.errors.filter((e) => !/favicon/i.test(e));check('Keine Konsolenfehler im Renderer (vor dem Neustart)', relevant.length === 0, relevant.slice(0, 2).join(' | ').slice(0, 120));