fluidcad 0.0.38 → 0.0.39

package/lib/dist/tests/features/loft-conditions.test.js

@@ -0,0 +1,246 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render, addToScene } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import plane from "../../core/plane.js";
+import loft from "../../core/loft.js";
+import extrude from "../../core/extrude.js";
+import { rect, circle } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+import { ShapeProps } from "../../oc/props.js";
+/** Volume of the loft's single solid. */
+function volumeOf(l) {
+    const shapes = l.getShapes();
+    expect(shapes).toHaveLength(1);
+    return ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+}
+function circlePair(diameter1, diameter2, height) {
+    const s1 = sketch("xy", () => {
+        circle(diameter1);
+    });
+    const s2 = sketch(plane("xy", { offset: height }), () => {
+        circle(diameter2);
+    });
+    return [s1, s2];
+}
+describe("loft start/end conditions", () => {
+    setupOC();
+    describe("normal condition", () => {
+        it("reproduces an exact cylinder for identical stacked circles", () => {
+            const [s1, s2] = circlePair(80, 80, 50);
+            const l = loft(s1, s2).startCondition("normal").endCondition("normal");
+            render();
+            // Perpendicular takeoff + identical profiles ⇒ straight sides.
+            const expected = Math.PI * 40 * 40 * 50;
+            expect(Math.abs(volumeOf(l) - expected) / expected).toBeLessThan(1e-4);
+        });
+        it("reproduces an exact box for identical stacked rectangles", () => {
+            const s1 = sketch("xy", () => {
+                rect(100, 50).centered();
+            });
+            const s2 = sketch(plane("xy", { offset: 40 }), () => {
+                rect(100, 50).centered();
+            });
+            const l = loft(s1, s2).startCondition("normal").endCondition("normal");
+            const sides = l.sideFaces();
+            addToScene(sides);
+            render();
+            const expected = 100 * 50 * 40;
+            expect(Math.abs(volumeOf(l) - expected) / expected).toBeLessThan(1e-4);
+            // Profile corners split the wall into one face per side, so the
+            // corners are real edges (renderable, selectable, filletable).
+            expect(sides.getShapes()).toHaveLength(4);
+        });
+        it("bulges a tapered loft outward compared to the unconstrained loft", () => {
+            const [p1, p2] = circlePair(80, 40, 50);
+            const plain = loft(p1, p2);
+            render();
+            const plainVolume = volumeOf(plain);
+            const [c1, c2] = circlePair(80, 40, 50);
+            const conditioned = loft(c1, c2).startCondition("normal").endCondition("normal");
+            render();
+            // Perpendicular takeoff at both ends swells the taper's waist.
+            expect(volumeOf(conditioned)).toBeGreaterThan(plainVolume * 1.02);
+        });
+    });
+    describe("tangent condition", () => {
+        it("turns identical stacked circles into a barrel", () => {
+            const [s1, s2] = circlePair(80, 80, 50);
+            const l = loft(s1, s2).startCondition("tangent").endCondition("tangent");
+            render();
+            const cylinder = Math.PI * 40 * 40 * 50;
+            const volume = volumeOf(l);
+            expect(volume).toBeGreaterThan(cylinder * 1.1);
+            expect(volume).toBeLessThan(cylinder * 2.0);
+        });
+        it("bulges more with a larger magnitude", () => {
+            const [s1, s2] = circlePair(80, 80, 50);
+            const smaller = loft(s1, s2).startCondition("tangent", 0.5).endCondition("tangent", 0.5);
+            render();
+            const smallerVolume = volumeOf(smaller);
+            const [b1, b2] = circlePair(80, 80, 50);
+            const bigger = loft(b1, b2).startCondition("tangent", 1.5).endCondition("tangent", 1.5);
+            render();
+            expect(volumeOf(bigger)).toBeGreaterThan(smallerVolume * 1.05);
+        });
+        it("pinches inward with a negative magnitude", () => {
+            const [s1, s2] = circlePair(80, 80, 50);
+            const l = loft(s1, s2).startCondition("tangent", -1).endCondition("tangent", -1);
+            render();
+            const cylinder = Math.PI * 40 * 40 * 50;
+            expect(volumeOf(l)).toBeLessThan(cylinder * 0.9);
+        });
+    });
+    describe("single-ended and mixed conditions", () => {
+        it("supports a start condition alone", () => {
+            const [s1, s2] = circlePair(80, 40, 50);
+            const l = loft(s1, s2).startCondition("normal");
+            render();
+            expect(volumeOf(l)).toBeGreaterThan(0);
+        });
+        it("supports an end condition alone", () => {
+            const [s1, s2] = circlePair(80, 40, 50);
+            const l = loft(s1, s2).endCondition("tangent");
+            render();
+            expect(volumeOf(l)).toBeGreaterThan(0);
+        });
+        it("resets a condition with 'none'", () => {
+            const [p1, p2] = circlePair(80, 80, 50);
+            const plain = loft(p1, p2);
+            render();
+            const plainVolume = volumeOf(plain);
+            const [s1, s2] = circlePair(80, 80, 50);
+            const l = loft(s1, s2).startCondition("tangent").startCondition("none");
+            render();
+            expect(Math.abs(volumeOf(l) - plainVolume) / plainVolume).toBeLessThan(1e-3);
+        });
+    });
+    describe("mixed profile kinds", () => {
+        it("lofts a rectangle to a circle with conditions (polynomial fallback)", () => {
+            const s1 = sketch("xy", () => {
+                rect(60, 60).centered();
+            });
+            const s2 = sketch(plane("xy", { offset: 50 }), () => {
+                circle(60);
+            });
+            const l = loft(s1, s2).startCondition("normal").endCondition("normal");
+            render();
+            const volume = volumeOf(l);
+            // Between the two prisms the shape must live inside.
+            expect(volume).toBeGreaterThan(Math.PI * 30 * 30 * 50 * 0.5);
+            expect(volume).toBeLessThan(60 * 60 * 50 * 1.5);
+        });
+        it("lofts through three profiles with end conditions", () => {
+            const s1 = sketch("xy", () => {
+                circle(60);
+            });
+            const s2 = sketch(plane("xy", { offset: 25 }), () => {
+                circle(100);
+            });
+            const s3 = sketch(plane("xy", { offset: 50 }), () => {
+                circle(60);
+            });
+            const l = loft(s1, s2, s3).startCondition("normal").endCondition("normal");
+            render();
+            expect(volumeOf(l)).toBeGreaterThan(0);
+        });
+    });
+    describe("classification and scene interplay", () => {
+        it("classifies start, end and side faces", () => {
+            const [s1, s2] = circlePair(80, 40, 50);
+            const l = loft(s1, s2).startCondition("normal").endCondition("normal");
+            const sf = l.startFaces();
+            const ef = l.endFaces();
+            const sidf = l.sideFaces();
+            addToScene(sf);
+            addToScene(ef);
+            addToScene(sidf);
+            render();
+            expect(sf.getShapes()).toHaveLength(1);
+            expect(ef.getShapes()).toHaveLength(1);
+            expect(sidf.getShapes().length).toBeGreaterThan(0);
+        });
+        it("fuses with existing scene geometry", () => {
+            const base = sketch("xy", () => {
+                rect(200, 200).centered();
+            });
+            extrude(-20, base);
+            const [s1, s2] = circlePair(80, 40, 50);
+            loft(s1, s2).startCondition("tangent");
+            const scene = render();
+            expect(countShapes(scene)).toBe(1);
+        });
+        it("cuts with remove mode", () => {
+            const base = sketch("xy", () => {
+                rect(200, 200).centered();
+            });
+            extrude(50, base);
+            const [s1, s2] = circlePair(80, 80, 50);
+            const l = loft(s1, s2).startCondition("normal").endCondition("normal").remove();
+            render();
+            // Normal-normal between identical circles is an exact cylinder, so the
+            // cut leaves the box volume minus the cylinder.
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            const remaining = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            const expected = 200 * 200 * 50 - Math.PI * 40 * 40 * 50;
+            expect(Math.abs(remaining - expected) / expected).toBeLessThan(1e-3);
+        });
+    });
+    describe("thin loft with conditions", () => {
+        it("builds a thin square-to-circle transition without booleans", () => {
+            const p1 = sketch("xy", () => {
+                rect(70, 70).centered();
+            });
+            const p2 = sketch(plane("xy", { offset: 80 }), () => {
+                circle(30);
+            });
+            const l = loft(p1, p2).startCondition("normal", 1).thin(2);
+            const sides = l.sideFaces();
+            const caps = l.startFaces();
+            addToScene(sides);
+            addToScene(caps);
+            render();
+            expect(l.getError()).toBeNull();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            // A ~2mm wall over an ~80-tall transition: far less material than the
+            // filled loft, far more than nothing. (The walls + ring caps are
+            // assembled directly — a boolean between the two shells used to take
+            // seconds.)
+            const volume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            expect(volume).toBeGreaterThan(10000);
+            expect(volume).toBeLessThan(60000);
+            // The outward offset rounds the outer wall's corners into arcs; the
+            // line→arc curvature jumps must still split faces (8 outer: 4 flats +
+            // 4 corner bands) alongside the sharp inner wall's 4 — otherwise the
+            // outer corners render smeared with no edges to select.
+            expect(sides.getShapes()).toHaveLength(12);
+            expect(caps.getShapes()).toHaveLength(1);
+        });
+        it("builds a thin-walled barrel", () => {
+            const [s1, s2] = circlePair(80, 80, 50);
+            const l = loft(s1, s2).thin(-4).startCondition("tangent").endCondition("tangent");
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            const volume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            const solidBarrelUpperBound = Math.PI * 40 * 40 * 50 * 2;
+            expect(volume).toBeGreaterThan(0);
+            expect(volume).toBeLessThan(solidBarrelUpperBound * 0.5);
+        });
+    });
+    describe("validation", () => {
+        it("rejects a magnitude with 'none'", () => {
+            const [s1, s2] = circlePair(80, 40, 50);
+            expect(() => loft(s1, s2).startCondition("none", 2)).toThrow(/magnitude has no effect/);
+        });
+        it("rejects unknown condition types", () => {
+            const [s1, s2] = circlePair(80, 40, 50);
+            expect(() => loft(s1, s2).startCondition("smooth")).toThrow(/expected 'none', 'normal' or 'tangent'/);
+        });
+        it("rejects a zero magnitude", () => {
+            const [s1, s2] = circlePair(80, 40, 50);
+            expect(() => loft(s1, s2).endCondition("normal", 0)).toThrow(/non-zero/);
+        });
+    });
+});

package/lib/dist/tests/features/loft-guides.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/loft-guides.test.js

@@ -0,0 +1,276 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render, addToScene } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import plane from "../../core/plane.js";
+import loft from "../../core/loft.js";
+import local from "../../core/local.js";
+import mirror from "../../core/mirror.js";
+import { rect, circle, move, vLine, bezier, polygon } from "../../core/2d/index.js";
+import { ShapeOps } from "../../oc/shape-ops.js";
+import { ShapeProps } from "../../oc/props.js";
+import { getOC } from "../../oc/init.js";
+function volumeOf(l) {
+    const shapes = l.getShapes();
+    expect(shapes).toHaveLength(1);
+    return ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+}
+/** Two identical circles (diameter 80) at z = 0 and z = 60. */
+function circleProfiles() {
+    const s1 = sketch("xy", () => {
+        circle(80);
+    });
+    const s2 = sketch(plane("xy", { offset: 60 }), () => {
+        circle(80);
+    });
+    return [s1, s2];
+}
+describe("loft guides", () => {
+    setupOC();
+    describe("single guide", () => {
+        it("reproduces a cylinder with a straight guide along the side", () => {
+            const [s1, s2] = circleProfiles();
+            // Straight rail touching both circles at (40, 0, z).
+            const guide = sketch("xz", () => {
+                move([40, 0]);
+                vLine(60);
+            });
+            const l = loft(s1, s2).guides(guide);
+            render();
+            const cylinder = Math.PI * 40 * 40 * 60;
+            expect(Math.abs(volumeOf(l) - cylinder) / cylinder).toBeLessThan(0.02);
+        });
+        it("follows a bulged guide sideways", () => {
+            const [s1, s2] = circleProfiles();
+            // Rail bowing out to x ≈ 52.5 at mid-height.
+            const guide = sketch("xz", () => {
+                bezier([40, 0], [65, 30], [40, 60]);
+            });
+            const l = loft(s1, s2).guides(guide);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            // The section rides the rail: the mid of the solid shifts in +x,
+            // so it must reach past the straight cylinder's x = 40 side.
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX).toBeGreaterThan(46);
+            expect(bbox.minZ).toBeCloseTo(0, 0);
+            expect(bbox.maxZ).toBeCloseTo(60, 0);
+            // Riding a rail translates sections without distorting them, so the
+            // volume stays near the straight cylinder's (and a broken sweep frame
+            // would show up here as a degenerate or wildly wrong solid).
+            const cylinder = Math.PI * 40 * 40 * 60;
+            const volume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            expect(volume).toBeGreaterThan(cylinder * 0.85);
+            expect(volume).toBeLessThan(cylinder * 1.3);
+        });
+        it("consumes the guide sketch", () => {
+            const [s1, s2] = circleProfiles();
+            const guide = sketch("xz", () => {
+                move([40, 0]);
+                vLine(60);
+            });
+            loft(s1, s2).guides(guide);
+            render();
+            expect(guide.getShapes()).toHaveLength(0);
+        });
+        it("classifies start and end faces", () => {
+            const [s1, s2] = circleProfiles();
+            const guide = sketch("xz", () => {
+                move([40, 0]);
+                vLine(60);
+            });
+            const l = loft(s1, s2).guides(guide);
+            const sf = l.startFaces();
+            const ef = l.endFaces();
+            addToScene(sf);
+            addToScene(ef);
+            render();
+            expect(sf.getShapes()).toHaveLength(1);
+            expect(ef.getShapes()).toHaveLength(1);
+        });
+    });
+    describe("two guides", () => {
+        it("accepts one sketch carrying two separate guide curves (mirror)", () => {
+            // Square (corners at ±25√2 on the sketch axes) lofted to a circle,
+            // steered by a bezier rail and its mirror sketched together.
+            const p1 = sketch("top", () => {
+                polygon(4, 50, "circumscribed");
+            });
+            const p2 = sketch(plane("top", 80), () => {
+                circle(30);
+            });
+            const g1 = sketch("right", () => {
+                bezier([Math.sqrt(2) * 25, 0], [50, 40], [15, 80]);
+                mirror(local("y"));
+            }).reusable();
+            const l = loft(p1, p2).guides(g1);
+            const sides = l.sideFaces();
+            addToScene(sides);
+            render();
+            expect(l.getError()).toBeNull();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            expect(ShapeProps.getProperties(shapes[0].getShape()).volumeMm3).toBeGreaterThan(0);
+            // The square's corners must be real edges: one wall face per side.
+            expect(sides.getShapes()).toHaveLength(4);
+            // Both rails bow out past the square's corners (±25√2 ≈ ±35.36).
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(Math.max(bbox.maxX, bbox.maxY)).toBeGreaterThan(36);
+            expect(Math.min(bbox.minX, bbox.minY)).toBeLessThan(-36);
+            expect(bbox.maxZ).toBeCloseTo(80, 0);
+        });
+        it("keeps the railed corner edges exactly on both rails (vertex matching)", () => {
+            const p1 = sketch("top", () => {
+                polygon(4, 50, "circumscribed");
+            });
+            const p2 = sketch(plane("top", 80), () => {
+                circle(30);
+            });
+            const g1 = sketch("right", () => {
+                bezier([Math.sqrt(2) * 25, 0], [50, 40], [15, 80]);
+                mirror(local("y"));
+            }).reusable();
+            const l = loft(p1, p2).guides(g1);
+            const sideEdges = l.sideEdges();
+            addToScene(sideEdges);
+            render();
+            // Rail radius at height z for bezier [(25√2,0),(50,40),(15,80)] (z = 80t).
+            const railRadius = (z) => {
+                const t = z / 80;
+                return (1 - t) * (1 - t) * Math.sqrt(2) * 25 + 2 * t * (1 - t) * 50 + t * t * 15;
+            };
+            // Exactly two corner edges (one per rail) must lie on the rails all
+            // the way up — no sideways drift, no radial deviation. The two
+            // un-railed corners taper straight and must not match.
+            const oc = getOC();
+            const point = new oc.gp_Pnt();
+            let railedEdges = 0;
+            for (const edge of sideEdges.getShapes()) {
+                const raw = oc.TopoDS.Edge(edge.getShape());
+                const info = oc.BRep_Tool.Curve(raw, 0, 1);
+                let maxDeviation = 0;
+                for (let i = 0; i <= 16; i++) {
+                    const t = info.First + ((info.Last - info.First) * i) / 16;
+                    info.returnValue.D0(t, point);
+                    const inPlane = Math.max(Math.abs(point.X()), Math.abs(point.Y()));
+                    const offPlane = Math.min(Math.abs(point.X()), Math.abs(point.Y()));
+                    maxDeviation = Math.max(maxDeviation, Math.abs(inPlane - railRadius(point.Z())), offPlane);
+                }
+                if (maxDeviation < 0.1) {
+                    railedEdges++;
+                }
+            }
+            point.delete();
+            expect(railedEdges).toBe(2);
+        });
+        it("rides both rails, bulging both sides of a rectangular loft", () => {
+            const s1 = sketch("xy", () => {
+                rect(80, 40).centered();
+            });
+            const s2 = sketch(plane("xy", { offset: 60 }), () => {
+                rect(80, 40).centered();
+            });
+            const right = sketch("xz", () => {
+                bezier([40, 0], [55, 30], [40, 60]);
+            });
+            const left = sketch("xz", () => {
+                bezier([-40, 0], [-55, 30], [-40, 60]);
+            });
+            const l = loft(s1, s2).guides(right, left);
+            render();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            const prism = 80 * 40 * 60;
+            const volume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            expect(volume).toBeGreaterThan(prism * 1.02);
+            expect(volume).toBeLessThan(prism * 1.5);
+            const bbox = ShapeOps.getBoundingBox(shapes[0]);
+            expect(bbox.maxX).toBeGreaterThan(42);
+            expect(bbox.minX).toBeLessThan(-42);
+            // The rails only pull in ±x — the section must not rotate or smear
+            // into y (B-rep bounds overshoot control hulls, hence the slack).
+            expect(bbox.maxY).toBeLessThan(26);
+            expect(bbox.minY).toBeGreaterThan(-26);
+        });
+    });
+    describe("guides with conditions", () => {
+        function guidedSquareToCircle(withCondition) {
+            const p1 = sketch("top", () => {
+                polygon(4, 50, "circumscribed");
+            });
+            const p2 = sketch(plane("top", 80), () => {
+                circle(30);
+            });
+            const g1 = sketch("right", () => {
+                bezier([Math.sqrt(2) * 25, 0], [50, 40], [15, 80]);
+                mirror(local("y"));
+            }).reusable();
+            // `.new()` — the two variants overlap almost everywhere; fusing two
+            // nearly-coincident B-spline solids is exactly the boolean OCC hates.
+            const l = loft(p1, p2).guides(g1).new();
+            if (withCondition) {
+                l.startCondition("normal");
+            }
+            return l;
+        }
+        it("applies a start condition away from the guide contacts", () => {
+            const plain = guidedSquareToCircle(false);
+            render();
+            expect(plain.getError()).toBeNull();
+            const plainVolume = ShapeProps.getProperties(plain.getShapes()[0].getShape()).volumeMm3;
+            const conditioned = guidedSquareToCircle(true);
+            render();
+            expect(conditioned.getError()).toBeNull();
+            const shapes = conditioned.getShapes();
+            expect(shapes).toHaveLength(1);
+            // The normal takeoff swells the un-guided sides of the square, so the
+            // conditioned loft encloses more material than the guided-only one —
+            // while the rails still pin the bulge to the same overall envelope.
+            const volume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            expect(volume).toBeGreaterThan(plainVolume * 1.01);
+            expect(volume).toBeLessThan(plainVolume * 1.5);
+        });
+        it("supports conditions on both ends alongside a guide", () => {
+            const [s1, s2] = circleProfiles();
+            const guide = sketch("xz", () => {
+                move([40, 0]);
+                vLine(60);
+            });
+            const l = loft(s1, s2)
+                .guides(guide)
+                .startCondition("tangent")
+                .endCondition("tangent");
+            render();
+            expect(l.getError()).toBeNull();
+            const shapes = l.getShapes();
+            expect(shapes).toHaveLength(1);
+            // Straight rail + tangent bulge: more volume than the plain cylinder,
+            // but the rail keeps its side straight so less than the free barrel.
+            const cylinder = Math.PI * 40 * 40 * 60;
+            const volume = ShapeProps.getProperties(shapes[0].getShape()).volumeMm3;
+            expect(volume).toBeGreaterThan(cylinder * 1.05);
+        });
+    });
+    describe("validation", () => {
+        it("rejects calling guides() with no arguments", () => {
+            const [s1, s2] = circleProfiles();
+            expect(() => loft(s1, s2).guides()).toThrow(/at least one guide/);
+        });
+        it("rejects more than two guides", () => {
+            const [s1, s2] = circleProfiles();
+            const g1 = sketch("xz", () => { move([40, 0]); vLine(60); });
+            const g2 = sketch("xz", () => { move([-40, 0]); vLine(60); });
+            const g3 = sketch("yz", () => { move([40, 0]); vLine(60); });
+            const l = loft(s1, s2).guides(g1, g2, g3);
+            render();
+            expect(l.getError()).toContain("at most two guide curves");
+        });
+        it("rejects combining guides with thin mode", () => {
+            const [s1, s2] = circleProfiles();
+            const guide = sketch("xz", () => { move([40, 0]); vLine(60); });
+            const l = loft(s1, s2).guides(guide).thin(-3);
+            render();
+            expect(l.getError()).toContain("thin");
+        });
+    });
+});

package/lib/dist/tests/features/repeat-sweep-borrowed-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/dist/tests/features/repeat-sweep-borrowed-path.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import sweep from "../../core/sweep.js";
+import repeat from "../../core/repeat.js";
+import fillet from "../../core/fillet.js";
+import { hLine, vLine, circle } from "../../core/2d/index.js";
+import { countShapes } from "../utils.js";
+// Regression: circular-repeating a sweep whose PATH is a bare curve borrowed
+// from another sketch (`pathSketch.regions.corner`). cloneWithTransform used to
+// deep-clone the path's 2D source chain (the fillet and the lines behind it)
+// out of its sketch and parent it under the repeat container. With no Sketch
+// ancestor those clones threw "Cannot read properties of null (reading
+// 'getPlane')". The borrowed path is now frozen into a transformed shape clone
+// instead of being rebuilt.
+describe("repeat circular of a sweep with a borrowed in-sketch path", () => {
+    setupOC();
+    it("renders every instance without orphaning the path's 2D source curves", () => {
+        const pathSketch = sketch("front", () => {
+            const up = vLine(20);
+            const across = hLine(20);
+            const corner = fillet(5, up, across).reusable();
+            return { corner };
+        });
+        sketch("top", () => {
+            circle(2);
+        });
+        const s1 = sweep(pathSketch.regions.corner);
+        repeat("circular", "z", { count: 3, angle: 360 }, s1);
+        const scene = render();
+        const errored = scene.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getType()}: ${o.getError()}`)).toEqual([]);
+        expect(countShapes(scene)).toBeGreaterThan(0);
+    });
+});

package/lib/dist/tests/features/rib.test.js

@@ -5,6 +5,7 @@ import extrude from "../../core/extrude.js";
 import shell from "../../core/shell.js";
 import fillet from "../../core/fillet.js";
 import rib from "../../core/rib.js";
+import plane from "../../core/plane.js";
 import { rect, circle, move, aLine, hLine } from "../../core/2d/index.js";
 import { Rib } from "../../features/rib.js";
 import { ShapeOps } from "../../oc/shape-ops.js";
@@ -277,6 +278,55 @@ describe("rib", () => {
                 expect(cVol / origVol).toBeLessThan(1.3);
             }
         });
+        it("repeat mirror keeps the parallel rib on the correct side", async () => {
+            const repeatModule = await import("../../core/repeat.js");
+            const repeat = repeatModule.default;
+            // Box centered on the origin and symmetric across the front (XZ) plane,
+            // so mirroring across "front" (Y → −Y) maps the scope onto itself. The
+            // correctly-mirrored rib is then congruent to the original reflected in
+            // Y only — its X and Z position are unchanged.
+            sketch("top", () => {
+                rect(100, 100).centered();
+            });
+            const box = extrude(60);
+            const s = shell(-4, box.endFaces());
+            // Diagonal spine on an offset front plane (Y = 20), placed off-centre in
+            // the XZ plane so that a flipped in-plane extrude direction would throw
+            // the rib to a clearly different X/Z position.
+            sketch(plane("front", 20), () => {
+                move([-30, 10]);
+                aLine(45, 25);
+            });
+            const r = rib(5).parallel().new().scope(s).extend();
+            repeat("mirror", "front", r);
+            render();
+            const bboxCenter = (shape) => {
+                const bb = ShapeOps.getBoundingBox(shape);
+                return {
+                    x: (bb.minX + bb.maxX) / 2,
+                    y: (bb.minY + bb.maxY) / 2,
+                    z: (bb.minZ + bb.maxZ) / 2,
+                };
+            };
+            expect(r.getShapes().length).toBeGreaterThan(0);
+            const orig = bboxCenter(r.getShapes()[0]);
+            const sceneMod = await import("../../scene-manager.js");
+            const scene = sceneMod.getCurrentScene();
+            const ribClones = scene.getSceneObjects().filter(o => o instanceof Rib && o !== r &&
+                o.getCloneSource() === r);
+            expect(ribClones.length).toBe(1);
+            const clone = ribClones[0];
+            expect(clone.getShapes().length).toBeGreaterThan(0);
+            const cl = bboxCenter(clone.getShapes()[0]);
+            // Mirroring across the front (XZ) plane flips Y only: the in-plane (X, Z)
+            // position must be preserved. Before the fix the clone's perpendicular
+            // extrude direction was negated (a cross product is a pseudovector under
+            // reflection), throwing the rib to the opposite side — its X/Z centre
+            // lands far from the original.
+            expect(Math.abs(cl.x - orig.x)).toBeLessThan(1);
+            expect(Math.abs(cl.z - orig.z)).toBeLessThan(1);
+            expect(Math.abs(cl.y + orig.y)).toBeLessThan(1);
+        });
         it("extended rib in .new() mode unifies coplanar artifact faces", () => {
             // The slab clips and scope cut leave coplanar sub-faces and seam edges
             // on flat walls of the rib. UnifySameDomain post-pass should merge