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

24.1 KB
Raw Blame
// Test für technische Zeichnungen (soma.drawing, E76): Der Codeblock des Skills „Technical drawings“ baut ohne Hinweise,
// Ansichten, Schnitt, Einzelheit und Maße landen als DXF, PDF und PNG, gleicher Inhalt gibt gleiche Dateien, die Prüfung
// meldet getippte Zahlen, Punkte neben Kanten, verdeckte Kanten, Text außerhalb und übereinander, Fehler nennen Datei und
// Zeile. Die Rückmeldungen des ersten Agent-Tests (Blatt „Feedback“): Zahlen, Ø, Lage des Durchmessertexts, mehrzeiliger
// Text, Schriftfeld, Stückliste, verschiebbare Beschriftung, Stufenschnitt, unterbrochene Ansicht, Gesamt-PDF.
// Dann in der echten App: die PDF öffnet im Code-Panel, Bild und PDF zählen nicht als ungespeicherte Änderung.
// Aufruf: npm run test:drawing (baut vorher). SMOKE_VISIBLE=offscreen SMOKE_SHOTS=1 legt ein Bild ab.
import { spawnSync } from 'node:child_process';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { APP, checker, cleanup, sleep, startApp } from './harness.mjs';

const t = checker();
const { check } = t;
let app;

const PY = process.env.SOMA_PYTHON || path.join(process.env.LOCALAPPDATA ?? '', 'soma-dev', 'venv', 'Scripts', 'python.exe');
const py = (args, opts = {}) => spawnSync(PY, args, { encoding: 'utf8', env: { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8' }, ...opts });
const soma = (dir, ...args) => py(['-m', 'soma', ...args, '--project', dir]);

// Passt zum Codeblock des Skills: Platte L x 60 x T mit vier Bohrungen, dazu ein Bolzen für den Schnitt mit ungeschnittenem Teil
const MODEL = `import cadquery as cq
from soma import add_part

L, W, T, HOLE = 120, 60, 12, 8
plate = (cq.Workplane("XY").box(L, W, T, centered=(True, True, False))
         .faces(">Z").workplane().rarray(90, 35, 2, 2).hole(HOLE)
         .faces(">Z").workplane().hole(10))
add_part("Bracket", plate)
add_part("Pin", cq.Workplane("XY").circle(5).extrude(30).translate((0, 0, -9)))
`;

// Absichtlich fehlerhafte Zeichnung: Jede Zeile löst genau eine Art Hinweis aus
const CHECKS = `from soma.drawing import Sheet
sh = Sheet("Checks", size="A3", scale="1:3")
front = sh.view(["Bracket", "Pin"], "front", at=(150, 200))
front.dim((-60, 0, 0), (60, 0, 0), offset=-10, text="125")
front.dim((-60, 0, 0), (-30, 0, 5), offset=-10)
front.dim((-41, 0, 6), (41, 0, 6), offset=-20)
sh.text("outside", (500, 100))
sh.text("one", (40, 40))
sh.text("one again", (41, 40.5))
sh.text("tiny", (40, 60), height=1.5)
cut = sh.section(["Bracket", "Pin"], "front", through=(0, 0, 0), at=(150, 120), name="A", unhatched=["Pin"])
b = sh.detail(front, (60, 0, 12), 5, at=(320, 120), scale="5:1", name="B")
sh.view("Bracket", "top", at=(330, 230), label="Top", label_at=(150, 188))
`;

// Rückmeldungen aus dem ersten Agent-Test: Zahlen ohne Nachkommastellen, kein doppeltes Ø, Text des Durchmessers in
// Richtung angle, eingerückter mehrzeiliger Text, Schriftfeld zu schmal, verschobene Beschriftung, Stufenschnitt mit
// Schnittverlauf, unterbrochene Ansicht, Maß auf ein Mittenkreuz ohne Bohrung, Positionsnummer in der Stückliste
const FEEDBACK = `from soma.drawing import Sheet, num
assert (num(130, 0), num(-0.0, 0), num(12.5)) == ("130", "0", "12.5"), num(130, 0)
sh = Sheet("Feedback", size="A3", scale="1:1", material="Birke Multiplex 18 mm")
top = sh.view("Bracket", "top", at=(100, 200), origin=(0, 0, 12))
top.diameter((0, 0, 12), 5, angle=90, text="Ø<> H7")
top.center_mark((20, -20, 12), 2.5)
top.dim((-60, -30, 12), (20, -20, 12), offset=-12)
sh.text("Notes:\\n  1. Deburr all edges, break sharp edges 0.3 x 45 degrees\\n  2. Anodize", (30, 280))
front = sh.view("Bracket", "front", at=(300, 230), breaks=[((-30, 0, 0), (30, 0, 0))], label="Shortened", label_at=(300, 255))
front.dim((-60, -30, 0), (60, -30, 0), offset=-10)
a = sh.section("Bracket", "front", path=[(-70, 17.5, 0), (-20, 17.5, 0), (-20, 0, 0), (70, 0, 0)], parent=top, name="A",
               at=(100, 110), letters_at=[(25, 225), (175, 225)])
sh.table([["1", "Bracket", "1"]], at=(230, 70), widths=[10, 40, 10])
top.leader((0, 0, 12), "1", at=(235, 65), end="dot")
w = sh.text_width("Ra 3.2")
assert 8 < w < 20 and sh.text_width("Ra 3.2\\nlonger second line") > 2 * w, w
tb = sh.table([["Pos", "Name"], ["2", "Very long part name"]], at=(30, 50))
assert abs((tb[2] - tb[0]) - (max(8, sh.text_width("Pos") + 4) + sh.text_width("Very long part name") + 4)) < 0.01, tb
top.leader((20, -20, 12), "Ra 3.2", at=(200, 262), side="left")
`;

const BROKEN = `from soma.drawing import Sheet
sh = Sheet("Broken")
sh.view("Brackett", "front", at=(100, 100))
`;

let dir;
try {
  // 1) soma drawing ohne App
  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'soma-drawing-'));
  fs.mkdirSync(path.join(dir, 'drawings'));
  fs.writeFileSync(path.join(dir, 'model.py'), MODEL);
  const skill = fs.readFileSync(path.join(APP, 'resources', 'skills', 'drawings.md'), 'utf8');
  // Platzhalter mit den Standardwerten aus dem Kopf, wie die App sie in die Kopie schreibt
  const defaults = Object.fromEntries([...skill.matchAll(/^var (\w+): ([^|]*?) \|/gm)].map((m) => [m[1], m[2].trim()]));
  const block = (/```python\r?\n([\s\S]*?)\r?\n```/.exec(skill)?.[1] ?? '').replace(/\{\{(\w+)\}\}/g, (all, k) => defaults[k] ?? all);
  fs.writeFileSync(path.join(dir, 'drawings', 'skill.py'), block + '\n');
  fs.writeFileSync(path.join(dir, 'drawings', 'checks.py'), CHECKS);
  fs.writeFileSync(path.join(dir, 'drawings', 'broken.py'), BROKEN);
  fs.writeFileSync(path.join(dir, 'drawings', 'feedback.py'), FEEDBACK);

  const b1 = soma(dir, 'drawing', 'build', '--json');
  let res = null;
  try { res = JSON.parse(b1.stdout); } catch { /* unten gemeldet */ }
  check('soma drawing build --json: drei Blätter gebaut, ein Fehler, Rückgabe 1', !!res && res.built.length === 3 && res.errors.length === 1 && b1.status === 1,
    (b1.stderr || b1.stdout).slice(-200));
  check('Gesamt-PDF wird bei einem Fehler nicht geschrieben (es fehlte ein Blatt)', res?.set?.skipped === true && !fs.existsSync(path.join(dir, 'output', 'drawings.pdf')),
    JSON.stringify(res?.set));
  const by = Object.fromEntries((res?.built ?? []).map((x) => [x.name, x]));
  const br = by.Bracket;
  check('Skill-Codeblock: Blatt "Bracket" mit 4 Ansichten (Vorder-, Draufsicht, Schnitt A-A, Einzelheit B) und ohne Hinweise',
    block.includes('soma.drawing') && br?.views.length === 4 && br.views.map((v) => v.kind).join(',') === 'view,view,section,detail' && br.warnings.length === 0,
    JSON.stringify(br?.warnings ?? res)?.slice(0, 200));
  check('Maße gemessen: 120 (L) und "4x Ø8" am Durchmesser', br?.dims.some((d) => d.label === '120') && br.dims.some((d) => d.label === '"4x Ø8"'),
    br?.dims.map((d) => d.label).join(' '));
  check('Dateien: PDF und DXF in output/drawings/, Bild in .soma/drawings/ (A3, 200 dpi)', ['output/drawings/Bracket.pdf', 'output/drawings/Bracket.dxf', '.soma/drawings/Bracket.png']
    .every((f) => fs.existsSync(path.join(dir, f))) && fs.readFileSync(path.join(dir, 'output/drawings/Bracket.pdf')).subarray(0, 5).toString() === '%PDF-'
    && br.png_size[0] === 3307, JSON.stringify(br?.png_size));
  const draw = br?.views.find((v) => v.name === 'top');
  check('Ansicht von oben kennt die Bohrungen: 4 x Ø8 mit Mitten, Ø10 in der Mitte', draw?.circles.filter((c) => c.diameter === 8 && !c.arc).length === 4
    && draw.circles.some((c) => c.diameter === 10 && c.center.join(',') === '0,0,12'), JSON.stringify(draw?.circles)?.slice(0, 160));

  // Index Version 2 für die Zeichnungsansicht der App: Ansichten, Maße und Hinweise mit Lage im Modell und auf dem Blatt
  let idx = null;
  try { idx = JSON.parse(fs.readFileSync(path.join(dir, '.soma', 'drawings', 'index.json'), 'utf8')); } catch { /* unten */ }
  check('index.json hat Version 2', idx?.version === 2, JSON.stringify(idx?.version));
  const j = (v) => JSON.stringify(v);
  const bv = Object.fromEntries((br?.views ?? []).map((v) => [v.name, v]));
  check('Ansicht: Teile, rechts/oben im Modell, Mitte und Größe (front: X rechts, Z oben; top: Y oben)',
    j(bv.front?.parts) === '["Bracket"]' && j(bv.front?.right) === '[1,0,0]' && j(bv.front?.up) === '[0,0,1]' && j(bv.front?.center) === '[0,0,6]'
    && bv.front.size === 120 && j(bv.top?.up) === '[0,1,0]' && j(bv.front.map) === '{"at":[140,190],"o":[0,6],"scale":0.5}',
    j(bv.front && { parts: bv.front.parts, right: bv.front.right, up: bv.front.up, center: bv.front.center, size: bv.front.size, map: bv.front.map }));
  check('Schnitt A-A: Ebene durch (0, 0, 0), Normale zur weggeschnittenen Seite = Blickrichtung', j(bv['A-A']?.section) === '{"kind":"plane","point":[0,0,0],"normal":[-1,0,0]}'
    && j(bv['A-A'].section.normal) === j(bv['A-A'].direction), j(bv['A-A']?.section));
  check('Einzelheit B: Mitte, Radius, Ausgangsansicht, Teile der Ausgangsansicht', j(bv.B?.detail) === '{"center":[20,0,12],"radius":4,"parent":"front"}'
    && j(bv.B.center) === '[20,0,12]' && j(bv.B.parts) === '["Bracket"]' && bv.B.size === 8, j(bv.B && { detail: bv.B.detail, size: bv.B.size }));
  const inside = (b, w, h) => Array.isArray(b) && b.length === 4 && b[0] >= 0 && b[1] >= 0 && b[2] <= w && b[3] <= h && b[0] < b[2] && b[1] < b[3];
  const within = (a, b) => a[0] >= b[0] - 0.01 && a[1] >= b[1] - 0.01 && a[2] <= b[2] + 0.01 && a[3] <= b[3] + 0.01;
  const d120 = br?.dims.find((d) => d.label === '120');
  const dDia = br?.dims.find((d) => d.kind === 'diameter');
  check('Maße: 3D-Punkte, Radius, Platz auf dem Blatt und Platz des Texts darin', j(d120?.points) === '[[-60,-30,12],[60,-30,12]]' && j(dDia?.points) === '[[45,17.5,12]]'
    && dDia.radius === 4 && br.dims.every((d) => inside(d.box, br.width, br.height) && inside(d.text_box, br.width, br.height) && within(d.text_box, d.box)),
    j(br?.dims.map((d) => ({ p: d.points, box: d.box, t: d.text_box }))));
  // Das Maß 120 liegt unter der Draufsicht (offset=-10): Box zwischen den Maßpunkten auf dem Blatt
  check('Maß 120: Box von x 110 bis 170 unter der Ansicht', d120 && Math.abs(d120.box[0] - 110) < 0.01 && Math.abs(d120.box[2] - 170) < 0.01 && d120.box[3] <= 80.01, j(d120?.box));
  const ck = by.Checks;
  const cw = (line, part) => ck?.warnings.find((x) => x.line === line && x.message.includes(part));
  check('Hinweise mit Ort auf dem Blatt (Maßtext, Punkt, Texte übereinander), Maßstab ohne Ort', inside(cw(4, 'differs')?.box, 420, 297) && inside(cw(5, 'lies on no edge')?.box, 420, 297)
    && inside(cw(9, 'overlaps')?.box, 420, 297) && !('box' in (cw(2, 'Scale 1:3') ?? { box: 1 })), j(ck?.warnings.map((x) => [x.line, x.box])));
  check('Ansicht mit eigener Liste: beide Teile', j(ck?.views.find((v) => v.name === 'front')?.parts) === '["Bracket","Pin"]');
  const fv = Object.fromEntries((by.Feedback?.views ?? []).map((v) => [v.name, v]));
  check('Stufenschnitt ohne Ebene, unterbrochene Ansicht mit breaks und gap in map', j(fv['A-A']?.section) === '{"kind":"path"}'
    && j(fv.front?.map?.breaks) === '[[0,-30,30]]' && fv.front.map.gap === 6, j({ s: fv['A-A']?.section, m: fv.front?.map }));
  // Die PDF-Seite ist genau das Blatt (Ursprung unten links, keine Ränder): MediaBox = Breite x Höhe in pt
  const media = /\/MediaBox\s*\[\s*0\s+0\s+([\d.]+)\s+([\d.]+)\s*\]/.exec(fs.readFileSync(path.join(dir, 'output', 'drawings', 'Bracket.pdf')).toString('latin1'));
  check('PDF-Seite genau 420 x 297 mm', !!media && Math.abs(+media[1] / 72 * 25.4 - 420) < 0.01 && Math.abs(+media[2] / 72 * 25.4 - 297) < 0.01, media?.[0]);

  const w = (by.Checks?.warnings ?? []).map((x) => `${x.line}: ${x.message}`);
  const has = (line, part) => w.some((m) => m.startsWith(`${line}: `) && m.includes(part));
  check('Prüfung: getippte Zahl "125" statt gemessener 120', has(4, 'differs from the measured 120'), w.join(' | ').slice(0, 200));
  check('Prüfung: Punkt (-30, 0, 5) liegt auf keiner Kante', has(5, 'lies on no edge'), w.filter((m) => m.startsWith('5:')).join(' | '));
  check('Prüfung: Maß an verdeckter Kante (Bohrungen in der Vorderansicht)', has(6, 'only on a hidden edge'), w.filter((m) => m.startsWith('6:')).join(' | '));
  check('Prüfung: Text außerhalb des Rahmens, Texte übereinander, Text unter 2.5 mm, Maßstab 1:3', has(7, 'beyond the frame') && has(9, 'overlaps Text "one"')
    && has(10, 'at least 2.5 mm') && has(2, 'Scale 1:3'), w.join(' | ').slice(0, 200));
  check('Keine Hinweise ohne Grund (Schnitt, Einzelheit, Gesamtmaß 120 an echten Kanten)', !w.some((m) => /^(3|11|12): /.test(m)),
    w.filter((m) => /^(3|11|12): /.test(m)).join(' | '));
  check('Prüfung: Ansichtstitel auf einem Maß, mit Hinweis auf label_at', has(13, 'Label "Top" lies on dimension') && has(13, 'label_at=(x, y)'),
    w.filter((m) => m.startsWith('13:')).join(' | '));

  const fb = by.Feedback;
  const fw = (fb?.warnings ?? []).map((x) => `${x.line}: ${x.message}`);
  const fhas = (line, part) => fw.some((m) => m.startsWith(`${line}: `) && m.includes(part));
  check('Schriftfeld: zu langer Werkstoff wird gemeldet', fhas(3, 'Title block: "Birke Multiplex 18 mm" does not fit the field Material'), fw.join(' | ').slice(0, 300));
  check('Positionsnummer in der Stückliste wird gemeldet (Text und Hinweislinie)', fhas(14, 'Text "1" overlaps the table of line 13') && fhas(14, 'The leader overlaps the table'),
    fw.join(' | ').slice(0, 300));
  check('Sonst keine Hinweise: Ø-Text frei, Maß auf das Mittenkreuz, mehrzeiliger Text im Rahmen, Stufenschnitt, unterbrochene Ansicht',
    !fw.some((m) => /^([4-9]|1[0-2]): /.test(m)), fw.filter((m) => /^([4-9]|1[0-2]): /.test(m)).join(' | '));
  check('Maße: Ø nicht doppelt ("Ø10 H7"), 80 bis zum Mittenkreuz, 120 über die Unterbrechung', ['"Ø10 H7"', '80', '120'].every((l) => fb?.dims.some((d) => d.label === l)),
    fb?.dims.map((d) => d.label).join(' '));
  check('text_width misst, Tabelle ohne widths passt sich den Texten an, Hinweislinie mit side="left": gebaut ohne Hinweise',
    !!fb && !fw.some((m) => /^(1[6-9]|20): /.test(m)), fw.filter((m) => /^(1[6-9]|20): /.test(m)).join(' | ') || JSON.stringify(res?.errors)?.slice(0, 300));
  const fbCheck = py(['-c', String.raw`
import json, sys, math, ezdxf
doc = ezdxf.readfile(sys.argv[1])
msp = doc.modelspace()
texts = [(t.dxf.text, tuple(round(v, 2) for v in t.dxf.align_point)[:2]) for t in msp.query("TEXT")]
dia = [d for d in msp.query("DIMENSION") if "H7" in d.dxf.text]
mt = [e for d in dia for e in d.virtual_entities() if e.dxftype() == "MTEXT"]
step = [l for l in msp.query("LINE[layer=='VISIBLE']") if abs(l.dxf.start.x - 80) < 0.01 and abs(l.dxf.end.x - 80) < 0.01 and 95 < l.dxf.start.y < 125]
print(json.dumps(dict(
    indent=any(t.startswith("  1. Deburr") for t, _p in texts), mtext=len(msp.query("MTEXT")),
    dimtext=[d.dxf.text for d in dia], ø=[e.plain_text() for e in mt], up=[round(e.dxf.insert.y - 200, 2) for e in mt],
    letters=sorted(p for t, p in texts if t == "A"), label=[p for t, p in texts if t == "Shortened"],
    ra=[p for t, p in texts if t == "Ra 3.2"],
    breaks=len([p for p in msp.query("LWPOLYLINE[layer=='THIN']") if len(p) == 6]),
    cut=[len(p) for p in msp.query("LWPOLYLINE[layer=='CUT']")], step=len(step))))
`, path.join(dir, 'output', 'drawings', 'Feedback.dxf')]);
  let fx = null;
  try { fx = JSON.parse(fbCheck.stdout); } catch { /* unten */ }
  check('Mehrzeiliger Text als Zeilen (kein MTEXT), Einrückung bleibt', fx?.indent === true && fx.mtext === 0, (fbCheck.stderr || fbCheck.stdout).slice(-200));
  check('Durchmesser: "Ø<> H7" wird "Ø10 H7", der Text steht in Richtung angle=90 (über der Mitte)', fx?.dimtext?.[0] === '<> H7' && fx.ø[0] === 'Ø10 H7' && fx.up[0] > 5,
    JSON.stringify(fx && { dimtext: fx.dimtext, ø: fx.ø, up: fx.up }));
  check('Hinweislinie mit side="left": Text endet 1 mm vor at', JSON.stringify(fx?.ra) === '[[199,263]]', JSON.stringify(fx?.ra));
  check('Buchstaben des Schnittverlaufs an letters_at, Titel an label_at', JSON.stringify(fx?.letters) === '[[25,225],[175,225]]' && JSON.stringify(fx?.label) === '[[300,255]]',
    JSON.stringify(fx && { letters: fx.letters, label: fx.label }));
  check('Stufenschnitt: Schnittverlauf mit 4 Punkten und zwei dicken Knicken, keine Kante an der Stufe; zwei Bruchlinien', JSON.stringify(fx?.cut) === '[4,3,3]' && fx.step === 0 && fx.breaks === 2,
    JSON.stringify(fx && { cut: fx.cut, step: fx.step, breaks: fx.breaks }));
  const err = res?.errors[0];
  check('Fehler: Datei, Zeile und die vorhandenen Bauteile', err?.file === 'drawings/broken.py' && err.line === 3 && err.message.includes("'Brackett' does not exist")
    && err.message.includes("'Bracket'"), JSON.stringify(err)?.slice(0, 160));

  // DXF: echte Maße, Schraffur nur am geschnittenen Teil, Linien der Einzelheit nur im Kreis
  const dxfCheck = py(['-c', String.raw`
import json, sys, math, ezdxf
from ezdxf import recover
doc, aud = recover.readfile(sys.argv[1])
msp = doc.modelspace()
types = {}
for e in msp:
    types[e.dxftype()] = types.get(e.dxftype(), 0) + 1
layers = sorted(l.dxf.name for l in doc.layers)
ok_detail = True
for e in msp.query("LINE[layer=='VISIBLE']"):
    for p in (e.dxf.start, e.dxf.end):
        if 290 < p.x < 370 and 40 < p.y < 120 and math.hypot(p.x - 330, p.y - 80) > 20.01:
            ok_detail = False
print(json.dumps(dict(errors=len(aud.errors), types=types, layers=layers, detail=ok_detail, hatches=len(msp.query("HATCH")))))
`, path.join(dir, 'output', 'drawings', 'Bracket.dxf')]);
  let dx = null;
  try { dx = JSON.parse(dxfCheck.stdout); } catch { /* unten */ }
  check('DXF ohne Fehler: 2 Maße als DIMENSION, Schraffur, Layer nach ISO 128', dx?.errors === 0 && dx.types.DIMENSION === 2 && dx.hatches >= 1
    && ['VISIBLE', 'HIDDEN', 'CENTER', 'DIM', 'HATCH', 'CUT'].every((l) => dx.layers.includes(l)), (dxfCheck.stderr || dxfCheck.stdout).slice(-200));
  check('Einzelheit B: Kanten nur im Kreis um ihre Mitte', dx?.detail === true);

  const before = ['Bracket.pdf', 'Bracket.dxf'].map((f) => fs.readFileSync(path.join(dir, 'output', 'drawings', f)));
  const png = fs.readFileSync(path.join(dir, '.soma', 'drawings', 'Bracket.png'));
  const b2 = soma(dir, 'drawing', 'build', 'drawings/skill.py');
  const after = ['Bracket.pdf', 'Bracket.dxf'].map((f) => fs.readFileSync(path.join(dir, 'output', 'drawings', f)));
  check('Gleicher Inhalt, gleiche Dateien: PDF, DXF und Bild bytegleich nach erneutem Bauen', b2.status === 0 && before.every((b, i) => b.equals(after[i]))
    && png.equals(fs.readFileSync(path.join(dir, '.soma', 'drawings', 'Bracket.png'))), b2.stdout.slice(0, 160));
  check('Ausgabe für den Agenten: Dateien und Hinweis auf das Bild', b2.stdout.includes('Drawing ok: "Bracket"') && b2.stdout.includes('output/drawings/Bracket.pdf')
    && b2.stdout.includes('.soma/drawings/Bracket.png (3307 x 2339 px)'), b2.stdout.slice(0, 300));
  const info = soma(dir, 'drawing', 'info', 'Bracket');
  check('soma drawing info: Ansichten mit Platz auf dem Blatt, Kreise, Maße mit Zeile', info.status === 0 && info.stdout.includes('Views:')
    && info.stdout.includes('circles: Ø10 x1 at (0, 0, 12); Ø8 x4') && /line \d+: 120 \(linear, top\)/.test(info.stdout), info.stdout.slice(0, 300));
  const list = soma(dir, 'drawing', 'list');
  check('soma drawing list: beide Blätter, der Fehler mit Zeile', list.stdout.includes('"Bracket"') && list.stdout.includes('"Checks"')
    && list.stdout.includes('ERROR drawings/broken.py:3'), list.stdout.slice(0, 300));

  fs.rmSync(path.join(dir, 'drawings', 'checks.py'));
  const b3 = soma(dir, 'drawing', 'build');
  check('Gelöschtes Blatt: PDF und DXF bleiben, die Ausgabe nennt sie, das Bild geht', b3.stdout.includes('Note: output/drawings/Checks.pdf belongs to no sheet anymore')
    && fs.existsSync(path.join(dir, 'output', 'drawings', 'Checks.pdf')) && !fs.existsSync(path.join(dir, '.soma', 'drawings', 'Checks.png')), b3.stdout.slice(-300));
  // Ohne Fehler: alle Blätter in output/drawings.pdf, nach Datei geordnet. Ein Teilbau holt die übrigen Blätter aus der DXF
  fs.rmSync(path.join(dir, 'drawings', 'broken.py'));
  const b5 = soma(dir, 'drawing', 'build');
  const setPdf = path.join(dir, 'output', 'drawings.pdf');
  const pages = (buf) => (buf.toString('latin1').match(/\/Type\s*\/Page[^s]/g) ?? []).length;
  const set1 = fs.existsSync(setPdf) ? fs.readFileSync(setPdf) : Buffer.alloc(0);
  check('Gesamt-PDF output/drawings.pdf mit beiden Blättern', b5.status === 0 && b5.stdout.includes('All sheets in one file: output/drawings.pdf (2 sheet(s))')
    && pages(set1) === 2, `${pages(set1)} Seiten; ${b5.stdout.slice(-200)}`);
  soma(dir, 'drawing', 'build', 'drawings/skill.py');
  check('Gesamt-PDF bytegleich nach Teilbau (Blatt aus der DXF gleich dem frisch gebauten)', fs.existsSync(setPdf) && set1.equals(fs.readFileSync(setPdf)));

  fs.appendFileSync(path.join(dir, 'model.py'), 'raise ValueError("kaputt")\n');
  const b4 = soma(dir, 'drawing', 'build');
  check('Modell baut nicht: Meldung mit Ort, keine Zeichnung', b4.status === 1 && b4.stderr.includes('The model does not build, so no drawing does either')
    && b4.stderr.includes('model.py:10'), b4.stderr.slice(-200));

  // 2) In der App: PDF im Code-Panel, nichts davon zählt als ungespeicherte Änderung
  app = await startApp({ name: 'drawing' });
  const { ev, waitFor } = app;
  await waitFor('Projekt und Build', () => !!window.__t && !!window.__t.project() && window.__t.status().state === 'ok');
  const proj = await ev(() => window.__t.project());
  fs.writeFileSync(path.join(proj.dir, 'model.py'), MODEL);
  fs.mkdirSync(path.join(proj.dir, 'drawings'), { recursive: true });
  fs.writeFileSync(path.join(proj.dir, 'drawings', 'bracket.py'), block + '\n');
  await waitFor('Modell gebaut', () => window.__t.status().state === 'ok' && window.__t.partCount() === 2, 90000).catch(() => {});
  // Erst wenn der Speicherstand model.py und drawings/ zählt: Er kommt aus einer Abfrage im Takt, sonst vergleicht der Test mit einem alten Stand
  await waitFor('Speicherstand', () => (window.__t.saveState()?.dirtyFiles ?? 0) >= 2, 10000).catch(() => {});
  const dirty0 = (await ev(() => window.__t.saveState())).dirtyFiles;
  const ab = soma(proj.dir, 'drawing', 'build');
  check('Im Projekt der App gebaut', ab.status === 0 && fs.existsSync(path.join(proj.dir, 'output', 'drawings', 'Bracket.pdf')), (ab.stderr || ab.stdout).slice(-200));
  await ev(() => window.__t.openCode('output/drawings/Bracket.pdf'));
  await waitFor('PDF gezeichnet', () => (window.__t.editor.state().pdf?.rendered ?? []).includes(1), 20000).catch(() => {});
  // Die Textebene baut pdf.js erst nach dem Zeichnen auf (pdfview.ts, TextLayer): Unter Last wäre sie sonst noch unvollständig
  await waitFor('Textebene', () => { const s = window.__t.editor.state().pdf?.text?.[0] ?? ''; return /Bracket/.test(s) && /120/.test(s) && /Ø/.test(s); }, 20000).catch(() => {});
  const pdf = (await ev(() => window.__t.editor.state())).pdf;
  const dark = await ev(() => {
    const c = document.querySelector('.pdf-page[data-page="1"] canvas');
    if (!c) return 0;
    const d = c.getContext('2d').getImageData(0, 0, c.width, c.height).data;
    let n = 0;
    for (let i = 0; i < d.length; i += 4) if (d[i] < 100) n++;
    return n;
  });
  check('PDF öffnet im Code-Panel: eine Seite im Querformat, mit Linien gezeichnet', pdf?.pages === 1 && dark > 1000, `${JSON.stringify(pdf)?.slice(0, 100)} dark=${dark}`);
  // Schrift ist als Kontur gezeichnet, darüber liegt unsichtbarer Text: markieren und zitieren geht wie in jeder PDF
  const ptext = (pdf?.text?.[0] ?? '').replace(/\s+/g, ' ');
  check('PDF hat eine Textebene: Name im Schriftfeld, Maßzahl und Ø lesbar', /Bracket/.test(ptext) && /120/.test(ptext) && /Ø/.test(ptext), ptext.slice(0, 160));
  await sleep(1500); // Dateibeobachtung und Speicherstand nachziehen lassen
  const dirty1 = (await ev(() => window.__t.saveState())).dirtyFiles;
  check('PDF, DXF und Bild zählen nicht als ungespeicherte Änderung', dirty1 === dirty0, `${dirty0} -> ${dirty1}`);
  if (process.env.SMOKE_SHOTS) {
    fs.mkdirSync(path.join(APP, 'test', 'shots'), { recursive: true });
    await sleep(600);
    await app.screenshot(path.join(APP, 'test', 'shots', '19-zeichnung.png')).catch((e) => console.log('Screenshot:', e.message));
  }
  const relevant = app.page.errors.filter((e) => !/favicon/i.test(e));
  check('Keine Konsolenfehler im Renderer', relevant.length === 0, relevant.slice(0, 2).join(' | ').slice(0, 100));
} catch (e) {
  console.log('ABBRUCH:', e.message);
  t.fail();
}
if (app) { await app.stop(); cleanup(app.ud); }
if (dir) cleanup(dir);
console.log(t.fails ? `\n${t.fails} Prüfung(en) fehlgeschlagen` : '\nALLE PRÜFUNGEN BESTANDEN');
process.exit(t.fails ? 1 : 0);