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: Ladeanzeige mit Abbrechen für die Explosion, Messen bereitet sich beim Einschalten vor
Kai-Jungsthoefelf0b70a9faec0
diff --git a/app/src/main/main.ts b/app/src/main/main.tsindex 9fb9088..2fe291d 100644--- a/app/src/main/main.ts+++ b/app/src/main/main.ts@@ -122,6 +122,8 @@ function registerIpc(ctl: ProjectController): void {ipcMain.handle('agents:detect', () => detectAgents(terminalEnv(dir())));ipcMain.handle('measure:query', (_e, source: unknown, req: unknown) => ctl.measure(source, req));+ ipcMain.handle('measure:start', () => ctl.measureStart());+ ipcMain.handle('measure:prepare', (_e, source: unknown, build: unknown) => ctl.measurePrepare(source, build));ipcMain.handle('skills:list', () => ctl.skills());ipcMain.handle('skills:set', (_e, id: unknown, mode: unknown) => ctl.setSkill(id, mode));ipcMain.handle('skills:configure', (_e, id: unknown, values: unknown) => ctl.configureSkill(id, values));diff --git a/app/src/main/measure.ts b/app/src/main/measure.tsindex 2ccff50..df113f2 100644--- a/app/src/main/measure.ts+++ b/app/src/main/measure.ts@@ -1,15 +1,16 @@import { spawn, type ChildProcess } from 'node:child_process';-import type { MeasureRequest, MeasureResponse } from '../shared/types';+import type { MeasurePrepared, MeasureRequest, MeasureResponse } from '../shared/types';import { pythonExe } from './paths';const START_TIMEOUT_MS = 60_000; // cadquery zu laden dauert beim ersten Mal einige Sekundenconst REQUEST_TIMEOUT_MS = 30_000;+const PREPARE_TIMEOUT_MS = 600_000; // große Baugruppen: Das BREP zu lesen kann Minuten dauerninterface Pending { resolve: (r: MeasureResponse) => void; timer: NodeJS.Timeout }/*** Langlebiger Python-Dienst pro Projekt für exakte Messungen (E24): `python -m soma serve`, JSON-Zeilen über- * stdin/stdout. Er startet erst bei der ersten Messung (cadquery zu laden kostet Sekunden) und bleibt dann offen.+ * stdin/stdout. Er startet erst mit dem Messmodus (cadquery zu laden kostet Sekunden) und bleibt dann offen.* Stürzt er ab, gilt die laufende Anfrage als fehlgeschlagen, die nächste startet ihn neu. Fehler sind Ergebnisse,* keine Ausnahmen: Die Oberfläche zeigt sie an.*/@@ -23,16 +24,33 @@ export class MeasureService {constructor(private readonly cwd: string) {}- async request(folder: string, req: MeasureRequest): Promise<MeasureResponse> {+ request(folder: string, req: MeasureRequest): Promise<MeasureResponse> {+ return this.send({ ...req, folder }, REQUEST_TIMEOUT_MS);+ }++ /** Den Dienst starten, ohne etwas zu messen (der Messmodus startet ihn beim Einschalten). */+ async warm(): Promise<MeasurePrepared> {if (this.disposed) return { ok: false, error: 'Das Modell ist geschlossen.' };- try { await this.start(); } catch (e) { return { ok: false, error: `Der Messdienst ließ sich nicht starten: ${e instanceof Error ? e.message : String(e)}` }; }+ try { await this.start(); return { ok: true }; }+ catch (e) { return { ok: false, error: `Der Messdienst ließ sich nicht starten: ${e instanceof Error ? e.message : String(e)}` }; }+ }++ /** Einen Stand vorab laden. Der Dienst arbeitet der Reihe nach: Messungen danach warten, bis er geladen ist. */+ async prepare(folder: string, build: string): Promise<MeasurePrepared> {+ const r = await this.send({ prepare: true, build, folder }, PREPARE_TIMEOUT_MS);+ return { ok: r.ok, error: r.error, stale: r.stale };+ }++ private async send(payload: Record<string, unknown>, timeoutMs: number): Promise<MeasureResponse> {+ const warm = await this.warm();+ if (!warm.ok) return warm;const proc = this.proc;if (!proc?.stdin) return { ok: false, error: 'Der Messdienst läuft nicht.' };const id = ++this.seq;return new Promise((resolve) => {- const timer = setTimeout(() => { this.pending.delete(id); resolve({ ok: false, error: 'Der Messdienst antwortet nicht (Zeitlimit).' }); }, REQUEST_TIMEOUT_MS);+ const timer = setTimeout(() => { this.pending.delete(id); resolve({ ok: false, error: 'Der Messdienst antwortet nicht (Zeitlimit).' }); }, timeoutMs);this.pending.set(id, { resolve, timer });- proc.stdin!.write(JSON.stringify({ ...req, id, folder }) + '\n');+ proc.stdin!.write(JSON.stringify({ ...payload, id }) + '\n');});}diff --git a/app/src/main/projects.ts b/app/src/main/projects.tsindex 0d496bf..cbb53c3 100644--- a/app/src/main/projects.ts+++ b/app/src/main/projects.ts@@ -3,7 +3,7 @@ import fs from 'node:fs';import os from 'node:os';import path from 'node:path';import type {- AnimBuildResult, AnimList, ExportResult, GitLog, MeasureEntity, MeasureRequest, MeasureResponse, ModelMap, OpenResult, PreviewResult,+ AnimBuildResult, AnimList, ExportResult, GitLog, MeasureEntity, MeasurePrepared, MeasureRequest, MeasureResponse, ModelMap, OpenResult, PreviewResult,ProjectInfo, RenderResult, RestoreResult, ResultEntry, SaveResult, SaveState, SkillInfo, SkillResult,} from '../shared/types';import { affectsAnimation } from '../shared/editable';@@ -353,11 +353,8 @@ export class ProjectController {*/async measure(source: unknown, req: unknown): Promise<MeasureResponse> {const s = this.need();- let folder: string;- const hash = (source as { preview?: unknown } | null)?.preview;- if (source === 'live') folder = path.join(s.dir, '.soma');- else if (typeof hash === 'string' && /^[0-9a-f]{7,40}$/.test(hash)) folder = path.join(previewsDir(), s.id, hash);- else return { ok: false, error: 'Unbekannte Quelle für die Messung.' };+ const folder = this.measureFolder(s, source);+ if (!folder) return { ok: false, error: 'Unbekannte Quelle für die Messung.' };const r = req as { build?: unknown; a?: unknown; b?: unknown } | null;const ent = (v: unknown): MeasureEntity | null => {const e = v as { part?: unknown; kind?: unknown; id?: unknown; point?: unknown; check?: unknown } | null;@@ -371,6 +368,27 @@ export class ProjectController {return s.measure.request(folder, clean);}+ /** Ordner des gemessenen Stands, den bestimmt der Hauptprozess. Unbekannte Quelle: null. */+ private measureFolder(s: Session, source: unknown): string | null {+ const hash = (source as { preview?: unknown } | null)?.preview;+ if (source === 'live') return path.join(s.dir, '.soma');+ if (typeof hash === 'string' && /^[0-9a-f]{7,40}$/.test(hash)) return path.join(previewsDir(), s.id, hash);+ return null;+ }++ /** Messdienst vorab starten, sobald der Nutzer den Messmodus einschaltet. */+ async measureStart(): Promise<MeasurePrepared> {+ return this.need().measure.warm();+ }++ /** Den angezeigten Stand vorab in den Messdienst laden. */+ async measurePrepare(source: unknown, build: unknown): Promise<MeasurePrepared> {+ const s = this.need();+ const folder = this.measureFolder(s, source);+ if (!folder || typeof build !== 'string') return { ok: false, error: 'Ungültige Messanfrage.' };+ return s.measure.prepare(folder, build);+ }+async restore(hash: string): Promise<RestoreResult> {const s = this.need();const commit = (await s.git.log()).find((c) => c.hash === hash);diff --git a/app/src/preload/preload.ts b/app/src/preload/preload.tsindex 8a438f5..6c302a6 100644--- a/app/src/preload/preload.ts+++ b/app/src/preload/preload.ts@@ -60,7 +60,11 @@ const api: SomaApi = {onExit: (cb) => { ipcRenderer.on('term:exit', (_e, id, code) => cb(id, code)); },},agents: { detect: () => ipcRenderer.invoke('agents:detect') },- measure: { query: (source, req) => ipcRenderer.invoke('measure:query', source, req) },+ measure: {+ query: (source, req) => ipcRenderer.invoke('measure:query', source, req),+ start: () => ipcRenderer.invoke('measure:start'),+ prepare: (source, build) => ipcRenderer.invoke('measure:prepare', source, build),+ },skills: {list: () => ipcRenderer.invoke('skills:list'),set: (id, mode) => ipcRenderer.invoke('skills:set', id, mode),diff --git a/app/src/renderer/busy.ts b/app/src/renderer/busy.tsnew file mode 100644index 0000000..2cfc4d3--- /dev/null+++ b/app/src/renderer/busy.ts@@ -0,0 +1,96 @@+import { $ } from './ui';++/** Erst nach dieser Zeit erscheint die Anzeige: Was schneller fertig ist, soll nicht aufblitzen. */+const SHOW_AFTER_MS = 200;++export interface BusyHandle {+ /** Anteil 0 bis 1, null: unbestimmt (der Balken läuft durch). */+ progress(f: number | null): void;+ /** Zweite Zeile, etwa der laufende Schritt. */+ detail(text: string): void;+ /** Schließen. Gehört die Anzeige inzwischen einem anderen, bleibt sie stehen. */+ close(): void;+}++/**+ * Ladeanzeige über dem Viewer, solange ein Werkzeug sich vorbereitet (Explosion: Strahltest bei großen Baugruppen). Sie deckt+ * den Viewer ab, Klicks ins Modell kämen sonst vor dem Ergebnis an. „Abbrechen“ und Escape beenden das Werkzeug. Es gibt immer+ * nur eine: Wer neu anfängt, übernimmt sie. Messen zeigt seine Vorbereitung in der eigenen Karte, dort darf man schon klicken.+ */+export class Busy {+ private owner = 0;+ private cancel: (() => void) | null = null;+ private timer: ReturnType<typeof setTimeout> | undefined;+ private t0 = 0;+ private tick: ReturnType<typeof setInterval> | undefined;+ private root = $('viewer-busy');+ private title = $('viewer-busy-title');+ private sub = $('viewer-busy-detail');+ private time = $('viewer-busy-time');+ private bar = $('viewer-busy-bar');+ private fill = $('viewer-busy-fill');++ constructor() {+ $('btn-busy-cancel').addEventListener('click', () => this.abort());+ window.addEventListener('keydown', (e) => {+ if (this.root.hidden || e.key !== 'Escape' || e.defaultPrevented) return;+ const t = e.target as HTMLElement | null;+ if (t?.closest?.('#terminals, #code-view, input, textarea, .menu')) return;+ e.preventDefault();+ this.abort();+ }, true); // vor den Werkzeugen: Escape bricht das Laden ab, nicht mehr+ }++ /** `cancel`: was „Abbrechen“ tut (das Werkzeug beenden). */+ show(title: string, cancel: () => void): BusyHandle {+ const id = ++this.owner;+ this.cancel = cancel;+ this.title.textContent = title;+ this.sub.textContent = '';+ this.time.textContent = '';+ this.setProgress(null);+ clearTimeout(this.timer);+ clearInterval(this.tick);+ this.root.hidden = true;+ this.t0 = performance.now();+ this.timer = setTimeout(() => {+ if (id !== this.owner) return;+ this.root.hidden = false;+ // Sekunden mitzählen: Auch ohne Fortschritt sieht man, dass noch etwas geschieht+ this.tick = setInterval(() => { this.time.textContent = `${Math.round((performance.now() - this.t0) / 1000)} s`; }, 1000);+ }, SHOW_AFTER_MS);+ const mine = () => id === this.owner;+ return {+ progress: (f) => { if (mine()) this.setProgress(f); },+ detail: (text) => { if (mine()) this.sub.textContent = text; },+ close: () => { if (mine()) this.hide(); },+ };+ }++ get visible(): boolean { return !this.root.hidden; }+ /** Für Tests: Titel und Zeile darunter, null wenn nichts lädt. */+ state(): { title: string; detail: string; progress: number | null } | null {+ if (!this.cancel) return null;+ const w = this.fill.style.width;+ return { title: this.title.textContent ?? '', detail: this.sub.textContent ?? '', progress: this.bar.classList.contains('indet') ? null : parseFloat(w) / 100 };+ }++ private setProgress(f: number | null): void {+ this.bar.classList.toggle('indet', f === null);+ this.fill.style.width = f === null ? '' : `${Math.round(Math.min(1, Math.max(0, f)) * 100)}%`;+ }++ private abort(): void {+ const c = this.cancel;+ this.hide();+ c?.();+ }++ private hide(): void {+ this.owner++;+ this.cancel = null;+ clearTimeout(this.timer);+ clearInterval(this.tick);+ this.root.hidden = true;+ }+}diff --git a/app/src/renderer/explodetool.ts b/app/src/renderer/explodetool.tsindex cb1aa82..d0d5cc6 100644--- a/app/src/renderer/explodetool.ts+++ b/app/src/renderer/explodetool.ts@@ -1,3 +1,4 @@+import type { Busy } from './busy';import { icon } from './icons';import type { BlockMap, ExplodePart, Viewer } from './viewer';@@ -24,6 +25,8 @@ interface Ui {}interface Deps {viewer: Viewer;+ /** Ladeanzeige, solange die Analyse rechnet (große Baugruppen: Sekunden). */+ busy: Busy;/** Vor dem Einschalten: Gemessen wird nur in Einbaulage, die exakte Geometrie kennt keine Explosion. */beforeOn: () => void;/** Die Bauteile stehen still (Schieber losgelassen, Bewegung zu Ende), etwa für den Bereich des Schnitts. */@@ -469,6 +472,8 @@ export class ExplodeTool {private trails = true;/** Laufende Bewegung. Beim Abspielen mit Ziel, damit ein neues Tempo von der aktuellen Lage aus weiterläuft. */private anim: { stop(): void; goal?: { target: number; play: boolean } } | null = null;+ /** Laufende Analyse (Strahltest), abbrechbar. */+ private loading: AbortController | null = null;private ui: Required<Ui>;constructor(ui: Ui, private deps: Deps) {@@ -510,11 +515,25 @@ export class ExplodeTool {if (on !== this.active) {this.active = on;this.ui.button.setAttribute('aria-pressed', String(on));- this.ui.card.hidden = !on;this.ui.viewerEl.classList.toggle('exploding', on);- if (on) { this.deps.beforeOn(); this.compute(); }this.stepPos = null;+ if (on) {+ this.deps.beforeOn();+ if (!this.analysis) {+ // Die Karte erscheint erst mit dem Ergebnis, bis dahin zeigt die Ladeanzeige den Fortschritt+ this.ui.card.hidden = true;+ void this.prepare(() => { this.compute(); this.ui.card.hidden = false; this.goTo(true, animate); });+ return;+ }+ this.compute();+ } else this.cancelLoad();+ this.ui.card.hidden = !on;}+ if (this.loading) return; // noch keine Analyse, prepare() fährt danach auseinander+ this.goTo(on, animate);+ }++ private goTo(on: boolean, animate: boolean): void {const target = on ? this.amount : 0;if (animate) this.moveTo(target);else if (this.anim || this.shown !== target) { this.stopAnim(); this.show(target); this.deps.settled(); }@@ -524,10 +543,55 @@ export class ExplodeTool {/** Neues Modell (Build oder anderer Stand): neu analysieren, die Explosion bleibt so weit, wie sie war. */refresh(): void {this.analysis = null;- if (!this.active && this.shown <= 0) { this.plan = null; return; } // erst beim Einschalten rechnen- this.compute();- if (this.shown > 0) this.show(this.shown);- this.render();+ this.cancelLoad();+ if (!this.active) { // erst beim Einschalten rechnen. Läuft noch das Zusammenfahren: gleich in Einbaulage+ if (this.shown > 0) { this.stopAnim(); this.show(0); }+ this.plan = null;+ return;+ }+ if (this.anim?.goal) this.stopAnim(); // ein laufender Schritt gehört zum alten Plan+ void this.prepare(() => {+ this.compute();+ if (this.shown > 0) this.show(this.shown);+ this.render();+ this.deps.settled();+ });+ }++ /**+ * Strahltest im Hintergrund mit Ladeanzeige, danach `then`. Abbrechen (Knopf, Escape) beendet die Explosion. Ein neuer Aufruf+ * oder cancelLoad() verwirft den laufenden, dessen `then` kommt dann nicht mehr.+ */+ private async prepare(then: () => void): Promise<void> {+ this.cancelLoad();+ const ctl = new AbortController();+ this.loading = ctl;+ const { viewer } = this.deps;+ const view = this.deps.busy.show('Explosion wird vorbereitet', () => this.setActive(false, false));+ try {+ // Strahltest und Hüllquader in Einbaulage+ if (this.shown > 0) viewer.setOffsets(null);+ const own = viewer.explodeParts().filter((p) => p.role !== 'reference');+ const size = diagonal(own);+ const t0 = performance.now();+ const { dirs, opp } = directions(own);+ view.detail(`${own.length} Bauteile: Was steht wem im Weg?`);+ const block = await viewer.explodeRays(own.map((p) => p.id), dirs, opp,+ { eps: Math.max(EPS_MIN, EPS * size), touch: Math.max(TOUCH_MIN, TOUCH * size), samples: SAMPLES },+ { signal: ctl.signal, progress: (f) => view.progress(f) });+ if (!block || this.loading !== ctl) return;+ this.analysis = { dirs, opp, block, ms: performance.now() - t0 };+ this.loading = null;+ then();+ } finally {+ if (this.loading === ctl) this.loading = null;+ view.close();+ }+ }++ private cancelLoad(): void {+ this.loading?.abort();+ this.loading = null;}/** Beschreibung für den Agenten, etwa beim Markieren. Ohne Explosion null. */@@ -537,23 +601,18 @@ export class ExplodeTool {return `Explosionsansicht (${Math.round(this.shown * 100)} %${step}): Die Bauteile sind nur zur Darstellung auseinandergezogen, ihre Lage im Bild ist nicht die Einbaulage`;}+ /** Plan und Lagen aus der Analyse (prepare() hat sie gerechnet). */private compute(): void {const { viewer } = this.deps;+ if (!this.analysis) return;// Ein laufender Schritt gehört zum alten Plan (seine Nummern stimmen nicht mehr)if (this.anim?.goal) this.stopAnim();- // Strahltest und Hüllquader in Einbaulage. Wer danach etwas zeigen will, ruft show() wieder auf.+ // Hüllquader in Einbaulage. Wer danach etwas zeigen will, ruft show() wieder auf.if (this.shown > 0) viewer.setOffsets(null);const parts = viewer.explodeParts();const own = parts.filter((p) => p.role !== 'reference');const size = diagonal(own);this.axis = autoAxis(parts);- if (!this.analysis) {- const t0 = performance.now();- const { dirs, opp } = directions(own);- const block = viewer.explodeRays(own.map((p) => p.id), dirs, opp,- { eps: Math.max(EPS_MIN, EPS * size), touch: Math.max(TOUCH_MIN, TOUCH * size), samples: SAMPLES });- this.analysis = { dirs, opp, block, ms: performance.now() - t0 };- }const { dirs, opp, block } = this.analysis;this.plan = disassemble(own, dirs, opp, block, AXES[this.axis]);this.near = layout(own, this.plan, GAP * size);@@ -820,7 +879,8 @@ export class ExplodeTool {const plan = this.plan;return {active: this.active, amount: this.amount, shown: this.shown, trails: this.trails, axis: this.axis,- moving: this.moving, forced: this.forced, animating: !!this.anim, analysisMs: this.analysis ? Math.round(this.analysis.ms) : null,+ // animating auch während der Analyse: Tests warten so auf die fertige Lage+ moving: this.moving, forced: this.forced, animating: !!this.anim || !!this.loading, loading: !!this.loading, analysisMs: this.analysis ? Math.round(this.analysis.ms) : null,base: plan?.base ?? null,steps: plan ? flatSteps(plan) : {},spreads: vec(this.near.offsets), far: vec(this.far.offsets),diff --git a/app/src/renderer/index.html b/app/src/renderer/index.htmlindex 9fb54f4..9898a1a 100644--- a/app/src/renderer/index.html+++ b/app/src/renderer/index.html@@ -92,6 +92,16 @@<section id="viewer" aria-label="3D-Ansicht"><div id="viewer-msg"></div>+ <!-- Ladeanzeige (busy.ts): Die Explosion rechnet bei großen Baugruppen einige Sekunden -->+ <div id="viewer-busy" class="vbusy" hidden>+ <div class="float vb-card" role="status" aria-live="polite">+ <div class="vb-hd"><span class="spin"><i data-icon="spin" data-size="16" data-stroke="2.4"></i></span><b id="viewer-busy-title"></b><span class="grow"></span><span id="viewer-busy-time" class="c3 small"></span></div>+ <div id="viewer-busy-detail" class="vb-sub"></div>+ <div id="viewer-busy-bar" class="vb-bar indet"><div id="viewer-busy-fill"></div></div>+ <div class="sc-actions"><button id="btn-busy-cancel" class="btn sm" title="Vorbereitung abbrechen und das Werkzeug beenden (Escape)">Abbrechen</button></div>+ </div>+ </div>+<!-- Oben links: was der Viewer zeigt (Modell oder ein Ergebnis des Agenten). In der Mitte die Werkzeuge. --><div id="vtop" class="vtop"><div id="view-switch" class="float switcher">diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.tsindex cd63d7e..5903630 100644--- a/app/src/renderer/main.ts+++ b/app/src/renderer/main.ts@@ -2,6 +2,7 @@ import { affectsBuild } from '../shared/editable';import type { AgentInfo, AnimEntry, BuildStatus, ExportResult, FileNode, ModelMap, PartMap, PreviewResult, ProjectInfo, ResultEntry, SaveState } from '../shared/types';import { CodePanel, codeRows, isPdf, type Mark } from './code';import { AnimTool } from './animtool';+import { Busy } from './busy';import { DRAG_FILE, FileTree, IMAGE_EXT, TEXT_EXT, VIDEO_EXT } from './filetree';import { hydrateIcons, icon } from './icons';import { Markup } from './markup';@@ -384,6 +385,8 @@ const sectionTool = new SectionTool({// ---- 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'),@@ -392,6 +395,7 @@ const explodeTool = new ExplodeTool({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@@ -1291,6 +1295,7 @@ if (api.testMode) {measure: () => measureTool.state(),section: () => sectionTool.state(),explode: () => explodeTool.state(),+ busy: () => busy.state(),anim: () => animTool.state(),animSeek: (t: number) => animTool.testSeek(t),animRefresh: () => animTool.refresh(),diff --git a/app/src/renderer/measuretool.ts b/app/src/renderer/measuretool.tsindex ece5d6e..71e12c5 100644--- a/app/src/renderer/measuretool.ts+++ b/app/src/renderer/measuretool.ts@@ -1,4 +1,5 @@import type { MeasureInfo, MeasureResponse, MeasureResult, MeasureSource, MeasureSpan, PartMap } from '../shared/types';+import { icon } from './icons';import { el } from './ui';import type { MeasureMarks, ProbeHit, Viewer } from './viewer';@@ -63,6 +64,15 @@ export class MeasureTool {private warm = false;/** Einmaliger Hinweis, etwa nach einem Klick auf die Schnittfläche. Verschwindet beim nächsten Klick. */private note = '';+ /**+ * Vorbereitung beim Einschalten: Messdienst starten, den Stand laden (große Baugruppen: Sekunden). Klicks sind schon+ * möglich, ihre Messung wartet darauf. `phase`: was gerade geschieht, leer wenn bereit.+ */+ private prep: Promise<void> | null = null;+ private prepSeq = 0;+ private phase = '';+ private prepT0 = 0;+ private prepTick: ReturnType<typeof setInterval> | undefined;constructor(private ui: Ui, private deps: Deps) {ui.button.addEventListener('click', () => this.setActive(!this.active));@@ -91,11 +101,53 @@ export class MeasureTool {this.ui.viewerEl.classList.toggle('measuring', on);this.deps.viewer.setMode(on ? 'measure' : 'select');this.clear();+ if (on) this.prepare(); else this.endPrepare();this.render();}- /** Neuer Build oder anderer Stand: Die IDs der Flächen und Kanten gelten nicht mehr. */- reset(): void { this.clear(); this.render(); }+ /** Neuer Build oder anderer Stand: Die IDs der Flächen und Kanten gelten nicht mehr, den neuen Stand vorab laden. */+ reset(): void {+ this.clear();+ if (this.active) this.prepare();+ this.render();+ }++ private prepare(): void {+ const build = this.deps.build();+ this.endPrepare();+ if (!build) return; // ohne Geometrie meldet der erste Klick, was fehlt+ const seq = this.prepSeq;+ const source = this.deps.source();+ const n = this.deps.viewer.partList().length;+ this.prepT0 = performance.now();+ // Sekunden mitzählen, nur die Zahl: Neu zeichnen ließe den laufenden Balken jedes Mal von vorn beginnen+ this.prepTick = setInterval(() => { const t = this.ui.body.querySelector('.mc-load-time'); if (t) t.textContent = this.prepSeconds(); }, 1000);+ this.phase = 'Messdienst startet …';+ this.prep = (async () => {+ // Läuft der Dienst schon, ist start() gleich fertig+ let r = await window.soma.measure.start().catch((e: unknown) => ({ ok: false, error: String(e), stale: false }));+ if (seq !== this.prepSeq) return;+ if (r.ok) {+ this.phase = `Geometrie wird geladen (${n} ${n === 1 ? 'Bauteil' : 'Bauteile'}) …`;+ this.render();+ r = await window.soma.measure.prepare(source, build).catch((e: unknown) => ({ ok: false, error: String(e), stale: false }));+ if (seq !== this.prepSeq) return;+ }+ // Ein veralteter Stand ist kein Fehler: Der neue Build ruft reset() und lädt selbst+ if (r.ok) this.warm = true;+ else if (!r.stale && !this.a) this.error = r.error ?? 'Der Messdienst ließ sich nicht vorbereiten.';+ this.endPrepare();+ this.render();+ })();+ }++ /** Vorbereitung beenden oder verwerfen (der Dienst lädt im Hintergrund zu Ende, das schadet nicht). */+ private endPrepare(): void {+ this.prepSeq++;+ this.prep = null;+ this.phase = '';+ clearInterval(this.prepTick);+ }private clear(): void {this.a = this.b = null;@@ -127,6 +179,7 @@ export class MeasureTool {const seq = ++this.seq;this.busy = true;this.render();+ if (this.prep) { await this.prep; if (seq !== this.seq) return; } // erst den Stand fertig laden, sonst läuft das Zeitlimitconst ent = (x: ProbeHit) => ({ part: x.partId, kind: x.kind, id: x.id, point: x.point, check: x.size ?? undefined });let r: MeasureResponse;try { r = await window.soma.measure.query(this.deps.source(), { build, a: ent(this.a!), ...(this.b ? { b: ent(this.b) } : {}) }); }@@ -195,9 +248,10 @@ export class MeasureTool {if (!this.active) return;const rows: HTMLElement[] = [];const hint = (t: string) => el('div', { className: 'mc-hint', textContent: t });- if (!this.a) rows.push(hint('Klick auf einen Punkt, eine Kante oder eine Fläche. Ein zweiter Klick misst Abstand und Winkel zum ersten.'));- else if (this.busy) rows.push(hint(this.warm ? 'Messe …' : 'Messe … Beim ersten Mal startet der Messdienst, das dauert einige Sekunden.'));- else if (this.error) rows.push(el('div', { className: 'mc-err', textContent: this.error }));+ if (this.phase) rows.push(this.loadingRow());+ if (this.error && !this.busy) rows.push(el('div', { className: 'mc-err', textContent: this.error }));+ else if (!this.a) rows.push(hint('Klick auf einen Punkt, eine Kante oder eine Fläche. Ein zweiter Klick misst Abstand und Winkel zum ersten.'));+ else if (this.busy) rows.push(hint(this.phase ? 'Gemessen wird, sobald die Geometrie geladen ist.' : this.warm ? 'Messe …' : 'Messe … Beim ersten Mal startet der Messdienst, das dauert einige Sekunden.'));else if (this.result && !this.result.b) {rows.push(...this.entityRows(this.result.a, true));rows.push(hint('Zweites Element anklicken für Abstand und Winkel.'));@@ -222,6 +276,19 @@ export class MeasureTool {agent.disabled = !this.result;}+ /** Was die Vorbereitung gerade tut, mit Sekunden und laufendem Balken. */+ private loadingRow(): HTMLElement {+ return el('div', { className: 'mc-load' },+ el('div', { className: 'mc-load-hd' }, el('span', { className: 'spin' }, icon('spin', 14, 2.4)), el('span', { className: 'grow', textContent: this.phase }),+ el('span', { className: 'c3 mc-load-time', textContent: this.prepSeconds() })),+ el('div', { className: 'vb-bar indet' }, el('div')));+ }++ private prepSeconds(): string {+ const s = Math.round((performance.now() - this.prepT0) / 1000);+ return s ? `${s} s` : '';+ }+private row(label: string, value: string): HTMLElement {return el('div', { className: 'mc-row' }, el('span', { textContent: label }), el('span', { className: 'v', textContent: value }));}@@ -284,6 +351,6 @@ export class MeasureTool {// ---- Prüfhilfe (nur Tests) ------------------------------------------------------------------------------------state() {- return { active: this.active, a: this.a, b: this.b, busy: this.busy, error: this.error, result: this.result, text: this.ui.body.textContent, agentText: this.agentText() };+ return { active: this.active, a: this.a, b: this.b, busy: this.busy, preparing: !!this.prep, phase: this.phase, error: this.error, result: this.result, text: this.ui.body.textContent, agentText: this.agentText() };}}diff --git a/app/src/renderer/style.css b/app/src/renderer/style.cssindex 76e29cb..a7e9992 100644--- a/app/src/renderer/style.css+++ b/app/src/renderer/style.css@@ -327,6 +327,16 @@ code { font-family:var(--mono); font-size:.95em; }#viewer.preview::after { content:''; position:absolute; inset:0; border:2px solid var(--vio); pointer-events:none; z-index:6; }#viewer-msg { position:absolute; left:50%; top:50%; transform:translate(-50%,-50%); color:var(--tx2); pointer-events:none; white-space:pre-wrap; text-align:center; z-index:1; max-width:70%; }#viewer-msg.error { color:var(--err); }+/* Ladeanzeige (busy.ts): deckt den Viewer ab, bis die Explosion bereit ist. Unter Banner und Markierung */+.vbusy { position:absolute; inset:0; z-index:5; display:flex; align-items:center; justify-content:center; background:rgba(18,20,23,.45); }+.vb-card { position:static; width:min(340px, calc(100% - 32px)); }+.vb-hd { display:flex; align-items:center; gap:9px; padding:12px 14px 4px; }+.vb-hd b { font-size:14px; }+.vb-sub { padding:0 14px; min-height:18px; font-size:12px; color:var(--tx2); overflow-wrap:anywhere; }+.vb-bar { position:relative; height:4px; margin:10px 14px 0; border-radius:2px; background:var(--s3); overflow:hidden; }+.vb-bar > div { height:100%; width:0; background:var(--acc); transition:width .15s; }+.vb-bar.indet > div { width:35%; position:absolute; animation:vb-run 1.2s ease-in-out infinite; transition:none; }+@keyframes vb-run { from { left:-35%; } to { left:100%; } }.float { position:absolute; z-index:2; background:rgba(24,27,31,.95); border:1px solid var(--line2); border-radius:10px; box-shadow:var(--shadow); }/* Bauteile (Entwurf 2): Baum in der Seitenleiste. Kompakte Zeilen, die Knöpfe erscheinen beim Überfahren@@ -403,6 +413,10 @@ code { font-family:var(--mono); font-size:.95em; }.mc-ico { color:var(--acc-tx); display:flex; }.mc-body { padding:0 0 4px; }.mc-hint { padding:2px 14px 6px; font-size:12px; color:var(--tx3); }+/* Vorbereitung des Messens (Messdienst, Geometrie): Zeile mit Sekunden und laufendem Balken */+.mc-load { padding:2px 0 10px; }+.mc-load-hd { display:flex; align-items:center; gap:8px; padding:0 14px; font-size:12px; color:var(--tx2); }+.mc-load .vb-bar { margin-top:8px; }.mc-err { margin:2px 12px 6px; padding:8px 10px; border-radius:6px; background:var(--err-tint); color:#ffc4c0; font-size:12px; }.mc-title { display:flex; align-items:baseline; gap:8px; padding:2px 14px 6px; min-width:0; }.mc-title b { font-size:13px; white-space:nowrap; }diff --git a/app/src/renderer/viewer.ts b/app/src/renderer/viewer.tsindex 0680f9c..6f6756f 100644--- a/app/src/renderer/viewer.ts+++ b/app/src/renderer/viewer.ts@@ -84,6 +84,8 @@ export interface RayHit { dist: number; touch: number; inside: number }/** Je Richtung: Bauteil → (Bauteil, das ihm in dieser Richtung im Weg steht → Treffer). */export type BlockMap = Map<string, Map<string, RayHit>>[];+/** So lange rechnet der Strahltest am Stück, bevor er die Oberfläche wieder zeichnen lässt. */+const YIELD_MS = 30;/** Punkte je Dreieck für den Strahltest (baryzentrisch), wichtigste zuerst: Mitte, nahe den Ecken, nahe den Kanten. */const SAMPLE_PATTERN = [[1 / 3, 1 / 3, 1 / 3], [0.7, 0.15, 0.15], [0.15, 0.7, 0.15], [0.15, 0.15, 0.7],[0.425, 0.425, 0.15], [0.15, 0.425, 0.425], [0.425, 0.15, 0.425]];@@ -1465,8 +1467,21 @@ export class Viewer {* zählen nicht) gehen Strahlen in jede Richtung, gegen alle Bauteile zugleich (BVH). Trifft ein Strahl von P aus Q im Abstand t,* stößt P in dieser Richtung nach t gegen Q, und Q stieße in der Gegenrichtung gegen P. Treffer unter `touch` zählen als* Berührung: Dort liegt P an. `opp[i]` ist die Gegenrichtung von `dirs[i]`. Höchstens etwa `samples` Punkte je Bauteil.+ * Bei großen Baugruppen dauert das Sekunden: Die Rechnung gibt regelmäßig die Oberfläche frei, meldet den Fortschritt (0 bis 1)+ * und hört auf, sobald `signal` abbricht (Ergebnis dann null).*/- explodeRays(ids: string[], dirs: number[][], opp: number[], opts: { eps: number; touch: number; samples: number }): BlockMap {+ async explodeRays(ids: string[], dirs: number[][], opp: number[], opts: { eps: number; touch: number; samples: number },+ ctl: { signal?: AbortSignal; progress?: (f: number) => void } = {}): Promise<BlockMap | null> {+ let last = performance.now();+ // Freigeben, damit die Ladeanzeige zeichnet und „Abbrechen“ ankommt. false: abgebrochen. Nur aufrufen, wenn `due()`:+ // Ein await je Strahlpunkt kostete merklich Zeit+ const due = () => performance.now() - last >= YIELD_MS;+ const breathe = async (f: number): Promise<boolean> => {+ ctl.progress?.(f);+ await new Promise((r) => setTimeout(r, 0));+ last = performance.now();+ return !ctl.signal?.aborted;+ };const chunks = ids.flatMap((id) => { const p = this.parts.get(id); return p ? [{ id, p, w: this.worldOf(p) }] : []; });// Dreiecke aller Teile in Einbaulage hintereinander. Die BVH ordnet nur den Index um, die Ecken bleiben: Über ihren// Bereich findet ein Treffer sein Bauteil.@@ -1495,12 +1510,17 @@ export class Viewer {};const out: BlockMap = dirs.map(() => new Map());if (!ni) return out;+ // Vor dem Aufbau der BVH einmal zeichnen lassen, der dauert bei großen Netzen selbst spürbar+ if (!await breathe(0)) return null;// Die BVH sortiert den Index beim Aufbau um: Die Punkte je Bauteil kommen aus einer Kopieconst tri = index.slice();const g = new THREE.BufferGeometry();g.setAttribute('position', new THREE.BufferAttribute(pos, 3));g.setIndex(new THREE.BufferAttribute(index, 1));const bvh = new MeshBVH(g);+ // Für den Fortschritt: Zahl der Dreiecke, von denen Strahlen ausgehen+ const total = range.reduce((n, r) => { const t = (r.i1 - r.i0) / 3; return n + (t ? Math.ceil(t / Math.max(1, Math.ceil(t / opts.samples))) : 0); }, 0) || 1;+ let done = 0;const note = (m: Map<string, Map<string, RayHit>>, a: string, b: string, dist: number, touch: number, inside: number) => {let row = m.get(a);if (!row) { row = new Map(); m.set(a, row); }@@ -1519,6 +1539,8 @@ export class Viewer {const per = Math.max(1, Math.min(SAMPLE_PATTERN.length, Math.floor(opts.samples / tris)));const stride = Math.max(1, Math.ceil(tris / opts.samples));for (let t = 0; t < tris; t += stride) {+ if (due() && !await breathe(done / total)) { g.dispose(); return null; }+ done++;const k = r.i0 + t * 3;A.fromArray(pos, tri[k] * 3); B.fromArray(pos, tri[k + 1] * 3); C.fromArray(pos, tri[k + 2] * 3);// Der Mesher legt die Dreiecke so, dass die Normale nach außen zeigt (gespiegelte Flächen umgedreht)diff --git a/app/src/shared/types.ts b/app/src/shared/types.tsindex 98934c1..57a0aa5 100644--- a/app/src/shared/types.ts+++ b/app/src/shared/types.ts@@ -92,6 +92,7 @@ export interface MeasurePair {export interface MeasureResult { build: string; a: MeasureInfo; b?: MeasureInfo; pair?: MeasurePair }/** `stale`: Die Anfrage gehört zu einem älteren Build, die Auswahl ist neu zu treffen. */export interface MeasureResponse { ok: boolean; result?: MeasureResult; error?: string; stale?: boolean }+export interface MeasurePrepared { ok: boolean; error?: string; stale?: boolean }/** Wert einer Einstellung eines Skills: Zahl oder gewählter Eintrag. */export type SkillValue = number | string;@@ -286,7 +287,13 @@ export interface SomaApi {};agents: { detect(): Promise<AgentInfo[]> };/** Exakte Messung über den Python-Dienst (E9, E24). */- measure: { query(source: MeasureSource, req: MeasureRequest): Promise<MeasureResponse> };+ measure: {+ query(source: MeasureSource, req: MeasureRequest): Promise<MeasureResponse>;+ /** Den Messdienst starten (cadquery laden), noch ohne Modell. Dauert beim ersten Mal einige Sekunden. */+ start(): Promise<MeasurePrepared>;+ /** Den Stand vorab in den Messdienst laden, damit der erste Klick nicht darauf wartet (große Baugruppen: Sekunden). */+ prepare(source: MeasureSource, build: string): Promise<MeasurePrepared>;+ };/** Skills des offenen Modells (E17): auflisten, Stufe wählen (E55). */skills: {list(): Promise<SkillInfo[]>;diff --git a/app/test/explode.mjs b/app/test/explode.mjsindex 4e4af6b..d4b0b2d 100644--- a/app/test/explode.mjs+++ b/app/test/explode.mjs@@ -91,6 +91,20 @@ try {screws.every((id) => JSON.stringify(byId[id].axis) === '[0,0,1]') && side.every((id) => JSON.stringify(byId[id].axis) === '[1,0,0]')&& JSON.stringify(byId[ids.Mutter].axis) === '[0,0,1]' && byId[ids.Deckel].axis === null, JSON.stringify(byId[ids.Mutter].axis));+ // 0b) Abbrechen während der Analyse (große Baugruppen rechnen Sekunden): Explosion aus, nichts verschoben, Karte zu+ const cancelled = await ev(() => {+ document.getElementById('btn-explode').click();+ const during = { loading: window.__t.explode().loading, busy: window.__t.busy() };+ document.getElementById('btn-busy-cancel').click();+ return { during, after: window.__t.explode(), busy: window.__t.busy(), card: document.getElementById('explode-card').hidden };+ });+ await sleep(300);+ check('Abbrechen während der Analyse: Explosion aus, Karte zu, Ladeanzeige weg, nichts verschoben',+ cancelled.during.loading && cancelled.during.busy?.title === 'Explosion wird vorbereitet' && !cancelled.after.active && !cancelled.after.loading+ && cancelled.card && cancelled.busy === null && !(await ev(() => window.__t.explode())).active && !Object.keys((await vs()).offsets).length+ && await ev(() => document.getElementById('viewer-busy').hidden && document.getElementById('btn-explode').getAttribute('aria-pressed') === 'false'),+ JSON.stringify(cancelled).slice(0, 160));+// 1) Einschalten: Demontage-Analyse, zunächst auf 50 %await domClick('btn-explode');await settle();@@ -345,7 +359,7 @@ try {// 7) Neuer Build: Die Explosion bleibt, die Analyse läuft neu (Deckel 6 mm dick)fs.writeFileSync(path.join(proj.dir, 'model.py'), MODEL(26));await waitFor('Neuer Build', () => window.__t.status().state === 'ok' && window.__t.partSize('Deckel')?.[2] === 6, 60000);- await sleep(200);+ await settle(); // die Analyse des neuen Stands läuft im Hintergrunds = await ex();vo = (await vs()).offsets;check('Nach dem Build: Explosion aktiv, zwölf Teile verschoben, Schrauben über dem neuen Deckel', s.active && Object.keys(vo).length === 12 && s.forced === 0diff --git a/app/test/measure.mjs b/app/test/measure.mjsindex 7952c7b..0aede1d 100644--- a/app/test/measure.mjs+++ b/app/test/measure.mjs@@ -51,11 +51,15 @@ try {check('„Messen": Modus an, Karte mit Hinweis, Auswahlkarte tritt zurück', s.active && s.text.includes('Klick auf einen Punkt, eine Kante oder eine Fläche')&& await ev(() => document.getElementById('btn-measure').getAttribute('aria-pressed') === 'true' && getComputedStyle(document.getElementById('selcard')).display === 'none'));- // 2) Eine Fläche: exakte Werte, Maße des Bauteils. Der erste Aufruf startet den Messdienst.+ check('Beim Einschalten startet die Vorbereitung (Messdienst, dann Geometrie), sichtbar in der Karte', s.preparing && s.text.includes('Messdienst startet'), s.phase);+ // Der erste Klick kommt noch während der Vorbereitung: Seine Messung wartet darauf statt ins Zeitlimit zu laufen++ // 2) Eine Fläche: exakte Werte, Maße des Bauteilsconst plateTop = await topFace('Platte', 5);await clickAt(plateTop.screen);await result(() => !!window.__t.measure().result);s = await ms();+ check('Nach der Vorbereitung: keine Ladezeile, kein Fehler', !s.preparing && !s.phase && !s.error, s.error);const expArea = 40 * 30 - 2 * Math.PI * 9;check('Klick auf die Oberseite der Platte: Fläche eben, exakter Flächeninhalt, Normale +Z', s.result?.a.type === 'PLANE' && Math.abs(s.result.a.area - expArea) < 1e-6&& s.text.includes('Fläche · eben') && s.text.includes('+Z'), s.error || `${s.result?.a.area}`);