fix(desktop): mechanisms print as their answers say, and a failed call leaves nothing behind

apps/desktop/e2e/solidcraft.contract.spec.ts

@@ -3281,8 +3281,8 @@ test('a hinge whose knuckles start above the bed carries them on webs at 45°: o
     await expect(page.getByTestId('connection-status')).toHaveAttribute('data-engine', 'headless', { timeout: 30_000 });
     await page.getByRole('textbox', { name: 'Message to the assistant' }).fill('Build a hinged case');
     await page.getByRole('button', { name: 'Send' }).click();
-    await expect(page.getByText(/Built the hinge "Case hinge" between Base \(stays\) and Flap \(turns\): 3 knuckles/)).toBeVisible({ timeout: 60_000 });
-    await expect(page.getByText(/3 knuckles start above the bed and stand on webs at 45° down to their own walls/)).toBeVisible();
+    await expect(page.getByText(/Built the hinge "Case hinge" between Base \(stays\) and Flap \(turns\): 5 knuckles/)).toBeVisible({ timeout: 60_000 });
+    await expect(page.getByText(/All 5 knuckles start above the bed and stand on webs at 45° that run from under the barrel down to their own wall, and the pin is flat underneath where it bridges from knuckle to knuckle, so the hinge prints as it stands, without support./)).toBeVisible();
     // With the webs the flap still folds all the way onto the base.
     await expect(page.getByText(/It turns from -179° to/)).toBeVisible();
     await expect(page.getByText(/Warning:/)).toHaveCount(0);
@@ -3292,8 +3292,8 @@ test('a hinge whose knuckles start above the bed carries them on webs at 45°: o
     const findings = page.getByTestId('print-check-panel');
     await expect(findings).toBeVisible();
     await page.waitForTimeout(1500);
-    // What is left hanging is the pin where it bridges the gaps between the knuckles.
-    await expect(findings.locator('[data-kind="overhang"]')).toContainText('25 mm²');
+    // Nothing is left hanging: the webs pass under the whole barrel, and the pin is flat where it bridges 6.5 mm from knuckle to knuckle.
+    await expect(findings.locator('[data-kind="overhang"]')).toHaveCount(0);
     await expect(findings.locator('[data-kind="blocked"], [data-kind="overlap"], [data-kind="thinWall"]')).toHaveCount(0);
     await page.screenshot({ path: test.info().outputPath('case-hinge.png') });
   } finally {
@@ -3322,7 +3322,7 @@ test('the assistant builds a print-in-place hinge with one call: one piece per b
     await page.getByRole('textbox', { name: 'Message to the assistant' }).fill('Build a hinged flap');
     await page.getByRole('button', { name: 'Send' }).click();
     // PartBuddy's answer to the tool: the gap is the nozzle of the printer in use, and the limits are where the plates meet.
-    await expect(page.getByText(/Built the hinge "Flap hinge" between Base \(stays\) and Flap \(turns\): 3 knuckles, barrel 6 mm, pin 3 mm, gap 0\.4 mm everywhere\. It turns from -145° to 67°/)).toBeVisible({ timeout: 60_000 });
+    await expect(page.getByText(/Built the hinge "Flap hinge" between Base \(stays\) and Flap \(turns\): 5 knuckles, barrel 6 mm, pin 3 mm, gap 0\.4 mm everywhere\. It turns from -145° to 67°/)).toBeVisible({ timeout: 60_000 });
     // The line was measured against both plates on trial, and the answer says how deep the knuckles' rooms go into each.
     // The line lies 2 mm from each plate, and a room is 3.4 mm about it.
     const rooms = page.getByText(/The knuckles' rooms go 1\.4 mm into Base and 1\.4 mm into Flap/);
@@ -3781,7 +3781,7 @@ test('a hinge whose line is out of reach of the bodies is taken back, with where
     await expect(page.getByTestId('connection-status')).toHaveAttribute('data-engine', 'headless', { timeout: 30_000 });
     await page.getByRole('textbox', { name: 'Message to the assistant' }).fill('Build a flap out of reach');
     await page.getByRole('button', { name: 'Send' }).click();
-    await expect(page.getByText(/Not built: 3 piece\(s\) did not touch their body and stand apart from it\. Put the hinge line within 2\.5 mm of both bodies .* Everything was taken back; call again with the line moved\./)).toBeVisible({ timeout: 60_000 });
+    await expect(page.getByText(/Not built: 5 piece\(s\) did not touch their body and stand apart from it\. Put the hinge line within 2\.5 mm of both bodies .* Everything was taken back./)).toBeVisible({ timeout: 60_000 });
     // The two plates are as they were: no knuckle, no cut, no joint.
     await expect(page.getByTestId('mesh-summary')).toContainText('2 bodies · 12 faces', { timeout: 30_000 });
     await expect(page.getByTestId('joints')).toHaveCount(0);

apps/desktop/src/main/agents/takeBack.ts

@@ -0,0 +1,76 @@
+/**
+ * Taking back what a tool built before it failed, shared by PartBuddy's own tools. The state before is kept as a mark:
+ * what `document.inspect` and `joint.list` name of the design (features, sketches, bodies, joints). Taking back undoes
+ * until the design reads like the mark again.
+ *
+ * Not by the difference of SolidCraft's undo depth alone: that depth stops at 200 (measured on 0.40.1: 260 steps read
+ * `undo: 200`), a hinge with webs costs over 50 steps, and from the fourth hinge on the difference came out too small
+ * or 0, so half a hinge or all of it stayed under "Everything was taken back" (review of PR #358).
+ */
+
+type Step = { command: string; params: Record<string, unknown> };
+/** Runs SolidCraft commands in turn and gives each one's result; throws when one fails. */
+export type Run = (commands: Step[]) => Promise<unknown[]>;
+
+export interface Mark {
+  /** What the design consists of, as one string to compare. */
+  state: string;
+  /** How many features its timeline has: undoing never goes below that, into what was there before. */
+  features: number;
+  /** SolidCraft's undo depth then; only a first guess at how many steps came since. */
+  undo: number | null;
+}
+
+/** More single steps than any tool builds: the search for the mark ends there. */
+const MOST = 400;
+
+const READ: Step[] = [
+  { command: 'document.inspect', params: { timeline: 'summary', bodies: 'names' } },
+  { command: 'joint.list', params: {} },
+];
+
+function markFrom(results: unknown[]): Mark | null {
+  const [design, joints] = results as [{ timeline?: unknown; sketches?: unknown; bodies?: unknown; undo?: unknown } | undefined, { joints?: unknown } | undefined];
+  // Without the timeline there is nothing to know the state by.
+  if (!Array.isArray(design?.timeline)) return null;
+  const ids = (list: unknown): unknown[] => (Array.isArray(list) ? (list as unknown[]).map((entry) => (entry as { id?: unknown } | null)?.id ?? entry) : []);
+  return { features: design.timeline.length, state: JSON.stringify([ids(design.timeline), ids(design.sketches), design.bodies ?? null, ids(joints?.joints)]), undo: typeof design.undo === 'number' ? design.undo : null };
+}
+
+/** The design as it is now, to come back to; null when SolidCraft does not say enough to know it again. */
+export async function markOf(run: Run): Promise<Mark | null> {
+  try {
+    return markFrom(await run(READ));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Undoes until the design is at `mark` again, and makes the design level active (activating a component is no undo
+ * step: after the undos it stays active, and what is built next lands in it). True only when the mark was reached;
+ * false when it could not be (no mark, nothing left to undo, more than `MOST` steps), and the caller must say so.
+ */
+export async function takeBack(run: Run, mark: Mark | null): Promise<boolean> {
+  const level = async () => {
+    await run([{ command: 'component.activate', params: { component: 0 } }]).catch(() => undefined);
+  };
+  if (!mark) {
+    await level();
+    return false;
+  }
+  try {
+    let now = markFrom(await run(READ));
+    // Where the depth has not hit its ceiling the difference is the number of steps: all at once, then looked at.
+    if (now && now.state !== mark.state && mark.undo !== null && now.undo !== null && now.undo > mark.undo) {
+      now = markFrom((await run([...Array.from({ length: now.undo - mark.undo }, () => ({ command: 'edit.undo', params: {} })), ...READ])).slice(-READ.length));
+    }
+    // One by one from there, as long as features built since are left: a step further would take what was there before.
+    for (let step = 0; now && now.state !== mark.state && now.features > mark.features && step < MOST; step += 1) now = markFrom((await run([{ command: 'edit.undo', params: {} }, ...READ])).slice(-READ.length));
+    await level();
+    return now?.state === mark.state;
+  } catch {
+    await level();
+    return false;
+  }
+}

apps/desktop/src/main/index.ts

@@ -590,7 +590,7 @@ if (!app.requestSingleInstanceLock()) {
         steps.tools(
           withDesignTool(
             withAssemblyTool(
-              withViewTool(guardNotes(withStandardTool(withPrintFaces(withBlockTool(withMechanismTool(withDrawings(upstream, drawings), () => printProfiles.part().printer.nozzle, keepMechanismFace), keepMechanismFace, log), keepMechanismFace)), (trial) => supervisor.trialSteps(trial)), () => viewState, () => notesService.forView(), checkForView),
+              withViewTool(guardNotes(withStandardTool(withPrintFaces(withBlockTool(withMechanismTool(withDrawings(upstream, drawings), () => printProfiles.part().printer.nozzle, keepMechanismFace, () => printProfiles.part().material.overhang), keepMechanismFace, log), keepMechanismFace)), (trial) => supervisor.trialSteps(trial)), () => viewState, () => notesService.forView(), checkForView),
               () => viewState?.bodies.map((body) => body.name) ?? [],
               saveAssembly,
             ),