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

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.ts
index 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 lassen
child.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.ts
index 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 Anlegen
app.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.ts
index 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}-sk
export 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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): void
function 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.ts
index 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.ts
index 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.mjs
index 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) || 93
const 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) || 93
child.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.mjs
index 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.mjs
index 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));