fluidcad 0.0.36 → 0.0.37

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

@@ -0,0 +1,347 @@
+import { describe, it, expect } from "vitest";
+import * as fs from "fs";
+import { join } from "path";
+import getSystemFonts from "get-system-fonts";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import select from "../../core/select.js";
+import cylinder from "../../core/cylinder.js";
+import helix from "../../core/helix.js";
+import { arc, circle, hLine, text } from "../../core/2d/index.js";
+import { edge } from "../../filters/index.js";
+import { getBoundingBoxOfShapes } from "../utils.js";
+import { FontRegistry } from "../../io/font-registry.js";
+const normFamily = (s) => s.trim().toLowerCase().replace(/\s+/g, " ");
+// The extruded solids produced by an extrude scene object (the real geometry,
+// excluding helper shapes like the sketch plane that countShapes would include).
+function solidsOf(e) {
+    return e.getShapes();
+}
+describe("text", () => {
+    setupOC();
+    it("extrudes standalone text on a plane into a solid", () => {
+        text("xy", "A").size(20);
+        const e = extrude(5);
+        render();
+        const solids = solidsOf(e);
+        expect(solids.length).toBeGreaterThanOrEqual(1);
+        const bbox = getBoundingBoxOfShapes(solids);
+        expect(bbox.maxX - bbox.minX).toBeGreaterThan(1); // has width
+        expect(bbox.maxY - bbox.minY).toBeGreaterThan(1); // has height
+        // ~5 (mesh bounding box overshoots exact geometry slightly).
+        expect(bbox.maxZ - bbox.minZ).toBeCloseTo(5, 0); // extruded depth
+        // Orientation: baseline sits at the plane origin (y=0); an "A" (no
+        // descender) must rise into +y and run in +x — i.e. upright, not flipped
+        // or mirrored.
+        expect(bbox.minY).toBeGreaterThan(-1);
+        expect(bbox.maxY).toBeGreaterThan(5);
+        expect(bbox.minX).toBeGreaterThan(-1);
+        expect(bbox.maxX).toBeGreaterThan(5);
+    });
+    it("renders text inside a sketch", () => {
+        sketch("xy", () => {
+            text("Hi").size(12);
+        });
+        const e = extrude(3);
+        render();
+        const solids = solidsOf(e);
+        expect(solids.length).toBeGreaterThanOrEqual(1);
+        const bbox = getBoundingBoxOfShapes(solids);
+        expect(bbox.maxZ - bbox.minZ).toBeCloseTo(3, 0); // ~3 (mesh bbox overshoot)
+    });
+    it("builds a letter with a counter (hole) such as 'o'", () => {
+        // Outer + inner contours must both build; FaceMaker2 drills the counter.
+        // We don't assert exact topology (font-dependent) — only a valid solid.
+        text("xy", "o").size(20);
+        const e = extrude(4);
+        render();
+        expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
+    });
+    it("falls back to a default font when the named font is missing", () => {
+        text("xy", "Z").size(20).font("NoSuchFont__XYZ");
+        const e = extrude(4);
+        render();
+        expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
+    });
+    it("honours font weight without throwing", () => {
+        text("xy", "B").size(20).weight("bold");
+        const e = extrude(4);
+        render();
+        expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
+    });
+    it("resolves named system fonts (does not collapse every font to one fallback)", () => {
+        const families = FontRegistry.availableFamilies();
+        expect(families.length).toBeGreaterThan(0);
+        // At least one installed family must resolve to itself. If openSync is
+        // mis-called (passing a postscriptName as a variation arg), every lookup
+        // throws and collapses to a single fallback font — this guards that.
+        const matched = families.some(f => normFamily(FontRegistry.resolve({ font: f }).familyName) === normFamily(f));
+        expect(matched).toBe(true);
+    });
+    it("loads a workspace-relative .ttf font file", async () => {
+        const files = await getSystemFonts();
+        const src = files.find(f => f.toLowerCase().endsWith(".ttf"));
+        if (!src) {
+            return; // no .ttf available to copy on this machine; skip
+        }
+        const root = process.env.FLUIDCAD_WORKSPACE_PATH;
+        fs.mkdirSync(join(root, "fonts"), { recursive: true });
+        fs.copyFileSync(src, join(root, "fonts", "test.ttf"));
+        text("xy", "A").size(20).font("fonts/test.ttf");
+        const e = extrude(5);
+        render();
+        expect(solidsOf(e).length).toBeGreaterThanOrEqual(1);
+    });
+});
+describe("text along a path", () => {
+    setupOC();
+    it("lays text upright along a straight sketch line", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("Hi", path).size(10);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        // Upright on the line: baseline at y=0 rising into +y, running in +x.
+        expect(bbox.minY).toBeGreaterThan(-1);
+        expect(bbox.maxY).toBeGreaterThan(4);
+        expect(bbox.minX).toBeGreaterThan(-1);
+        expect(bbox.maxX).toBeLessThan(50);
+        // Planar output in the sketch plane (z = 0); the bbox helper pads by 0.1.
+        expect(Math.abs(bbox.minZ)).toBeLessThan(0.2);
+        expect(Math.abs(bbox.maxZ)).toBeLessThan(0.2);
+    });
+    it("extrudes path text into a solid", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("Hi", path).size(10);
+        const e = extrude(5, t);
+        render();
+        const solids = solidsOf(e);
+        expect(solids.length).toBeGreaterThanOrEqual(1);
+        const bbox = getBoundingBoxOfShapes(solids);
+        expect(bbox.maxZ - bbox.minZ).toBeCloseTo(5, 0);
+    });
+    it("keeps every glyph on the ring when following a circle", () => {
+        const path = sketch("xy", () => {
+            circle(100); // diameter 100 -> radius 50
+        });
+        const t = text("FLUIDCAD", path).size(8).align("center");
+        render();
+        expect(t.getError()).toBeFalsy();
+        const shapes = t.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        // Each outline edge must hug the ring: its center stays within an
+        // annulus around radius 50 (giving the glyph height some slack).
+        for (const s of shapes) {
+            const b = getBoundingBoxOfShapes([s]);
+            const r = Math.hypot((b.minX + b.maxX) / 2, (b.minY + b.maxY) / 2);
+            expect(r).toBeGreaterThan(38);
+            expect(r).toBeLessThan(62);
+        }
+    });
+    it("offsets the baseline away from the path", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("Hi", path).size(10).offset(5);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        expect(bbox.minY).toBeGreaterThan(4);
+    });
+    it("flips text to the other side of the path", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("Hi", path).size(10).flip();
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        // Mirrored below the line.
+        expect(bbox.maxY).toBeLessThan(1);
+        expect(bbox.minY).toBeLessThan(-4);
+    });
+    it("starts at an arc-length distance along the path", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("I", path).size(10).startAt(30);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        expect(bbox.minX).toBeGreaterThan(25);
+        expect(bbox.maxX).toBeLessThan(45);
+    });
+    it("aligns right against the path end", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("Hi", path).size(10).align("right");
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        expect(bbox.maxX).toBeLessThan(101);
+        expect(bbox.maxX).toBeGreaterThan(85);
+    });
+    it("follows a standalone planar primitive and wraps on a closed path", () => {
+        // Text much longer than the circumference must wrap, not error.
+        const ring = circle("xy", 30); // radius 15, circumference ~94
+        const t = text("WRAPPING ALL THE WAY AROUND", ring).size(8);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        expect(bbox.minX).toBeGreaterThan(-35);
+        expect(bbox.maxX).toBeLessThan(35);
+        expect(bbox.minY).toBeGreaterThan(-35);
+        expect(bbox.maxY).toBeLessThan(35);
+    });
+    it("follows a circular edge selected from a solid", () => {
+        cylinder(30, 50);
+        const rim = select(edge().circle().onPlane("xy", { offset: 50 }));
+        const t = text("RIM", rim).size(6);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const shapes = t.getShapes();
+        expect(shapes.length).toBeGreaterThan(0);
+        // The fitted path plane is the rim's plane: all glyphs at z = 50
+        // (the bbox helper pads by 0.1).
+        const bbox = getBoundingBoxOfShapes(shapes);
+        expect(bbox.minZ).toBeGreaterThan(49.7);
+        expect(bbox.maxZ).toBeLessThan(50.3);
+    });
+    it("stacks multi-line text perpendicular to the path", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("AB\nCD", path).size(10);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        // Two lines: total height exceeds a single line's cap height.
+        expect(bbox.maxY - bbox.minY).toBeGreaterThan(10);
+        expect(bbox.minY).toBeLessThan(-4); // second line below the baseline
+    });
+    it("rejects a non-planar path", () => {
+        const h = helix("z").radius(20).pitch(10).turns(2);
+        const t = text("Hi", h);
+        render();
+        expect(t.getError()).toMatch(/planar/i);
+    });
+    it("rejects path-only modifiers without a path", () => {
+        const t = text("xy", "Hi").offset(3);
+        render();
+        expect(t.getError()).toMatch(/offset/i);
+    });
+    it("sits on the outside of a closed circle by default", () => {
+        const ring = circle("xy", 100); // radius 50
+        const t = text("OUTSIDE", ring).size(8);
+        render();
+        expect(t.getError()).toBeFalsy();
+        const radii = t.getShapes().map((s) => {
+            const b = getBoundingBoxOfShapes([s]);
+            return Math.hypot((b.minX + b.maxX) / 2, (b.minY + b.maxY) / 2);
+        });
+        const mean = radii.reduce((a, b) => a + b, 0) / radii.length;
+        expect(mean).toBeGreaterThan(50);
+    });
+    it("moves closed-path text inside with flip", () => {
+        const ring = circle("xy", 100); // radius 50
+        const t = text("INSIDE", ring).size(8).flip();
+        render();
+        expect(t.getError()).toBeFalsy();
+        const radii = t.getShapes().map((s) => {
+            const b = getBoundingBoxOfShapes([s]);
+            return Math.hypot((b.minX + b.maxX) / 2, (b.minY + b.maxY) / 2);
+        });
+        const mean = radii.reduce((a, b) => a + b, 0) / radii.length;
+        expect(mean).toBeLessThan(50);
+    });
+    it("justifies text across the full path with space-between", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("AB", path).size(10).align("space-between");
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        expect(bbox.minX).toBeLessThan(12);
+        expect(bbox.maxX).toBeGreaterThan(88);
+    });
+    it("leaves half a gap at each end with space-around", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("AB", path).size(10).align("space-around");
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        // Two glyphs each get half their leftover share at the run's ends, so
+        // the text stays well clear of both path ends and centers on the path.
+        expect(bbox.minX).toBeGreaterThan(10);
+        expect(bbox.maxX).toBeLessThan(90);
+        expect((bbox.minX + bbox.maxX) / 2).toBeCloseTo(50, 0);
+    });
+    it("accepts start/end alignment synonyms", () => {
+        const path = sketch("xy", () => {
+            hLine(100);
+        });
+        const t = text("Hi", path).size(10).align("end");
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        expect(bbox.maxX).toBeLessThan(101);
+        expect(bbox.maxX).toBeGreaterThan(85);
+    });
+    it("rejects space-between alignment without a path", () => {
+        const t = text("xy", "Hi").align("space-between");
+        render();
+        expect(t.getError()).toMatch(/space-between/i);
+    });
+    it("rejects space-around alignment without a path", () => {
+        const t = text("xy", "Hi").align("space-around");
+        render();
+        expect(t.getError()).toMatch(/space-around/i);
+    });
+    it("follows an arc drawn in the same sketch", () => {
+        let t;
+        sketch("xy", () => {
+            const a = arc([0, 0], [100, 0]).center([50, -200]).cw().guide();
+            t = text("Marwan", a).size(15);
+        });
+        render();
+        expect(t.getError()).toBeFalsy();
+        const bbox = getBoundingBoxOfShapes(t.getShapes());
+        // A shallow arc bulging up: text sits along it, above y = 0 won't hold
+        // everywhere, but it must stay near the arc band and inside x ∈ [0, 100].
+        expect(bbox.minX).toBeGreaterThan(-5);
+        expect(bbox.maxX).toBeLessThan(105);
+        expect(bbox.maxY).toBeGreaterThan(4);
+        // Planar in the sketch plane; the bbox helper pads by 0.1.
+        expect(Math.abs(bbox.minZ)).toBeLessThan(0.2);
+        expect(Math.abs(bbox.maxZ)).toBeLessThan(0.2);
+    });
+    it("extrudes in-sketch path text whose guide path stays out of the profile", () => {
+        sketch("xy", () => {
+            const a = arc([0, 0], [100, 0]).center([50, -200]).cw().guide();
+            text("Hi", a).size(12);
+        });
+        const e = extrude(4);
+        render();
+        const solids = solidsOf(e);
+        expect(solids.length).toBeGreaterThanOrEqual(1);
+        const bbox = getBoundingBoxOfShapes(solids);
+        expect(bbox.maxZ - bbox.minZ).toBeCloseTo(4, 0);
+    });
+    it("multiple texts can share one path", () => {
+        const ring = circle("xy", 100);
+        const outside = text("OUTSIDE", ring).size(8);
+        const inside = text("INSIDE", ring).size(8).flip();
+        render();
+        expect(outside.getError()).toBeFalsy();
+        expect(inside.getError()).toBeFalsy();
+    });
+});

package/lib/dist/tests/features/wrap-development.test.d.ts

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

package/lib/dist/tests/features/wrap-development.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import { CylinderDevelopment, ConeDevelopment } from "../../oc/wrap-development.js";
+import { Plane } from "../../math/plane.js";
+import { Point, Point2D } from "../../math/point.js";
+import { Vector3d } from "../../math/vector3d.js";
+// Pure-math tests for the wrap development mapping — no OCCT required.
+describe("wrap development", () => {
+    describe("cylinder", () => {
+        const spec = {
+            origin: new Point(0, 0, 0),
+            axisDir: new Vector3d(0, 0, 1),
+            radius: 25,
+        };
+        // Tangent plane at (25, 0, 0): local x is circumferential, local y is axial.
+        const tangentPlane = new Plane(new Point(25, 0, 0), new Vector3d(0, 1, 0), new Vector3d(1, 0, 0));
+        it("maps the sketch origin to its radial projection on the surface", () => {
+            const dev = new CylinderDevelopment(spec, tangentPlane);
+            const uv = dev.toUV(new Point2D(0, 0));
+            expect(uv.u).toBeCloseTo(0, 12);
+            expect(uv.v).toBeCloseTo(0, 12);
+            const anchor = dev.evalPoint(uv);
+            expect(anchor.x).toBeCloseTo(25, 12);
+            expect(anchor.y).toBeCloseTo(0, 12);
+            expect(anchor.z).toBeCloseTo(0, 12);
+        });
+        it("preserves arc length around the surface", () => {
+            const dev = new CylinderDevelopment(spec, tangentPlane);
+            const uv = dev.toUV(new Point2D(10, 0));
+            // 10 units of sketch length = 10 units of arc = 10/25 radians.
+            expect(Math.abs(uv.u)).toBeCloseTo(10 / 25, 12);
+            expect(uv.v).toBeCloseTo(0, 12);
+            const point = dev.evalPoint(uv);
+            const radial = Math.hypot(point.x, point.y);
+            expect(radial).toBeCloseTo(25, 12);
+            expect(point.z).toBeCloseTo(0, 12);
+        });
+        it("maps the axial sketch direction onto the surface axis", () => {
+            const dev = new CylinderDevelopment(spec, tangentPlane);
+            const point = dev.evalPoint(dev.toUV(new Point2D(0, 7)));
+            expect(point.x).toBeCloseTo(25, 12);
+            expect(point.y).toBeCloseTo(0, 12);
+            expect(point.z).toBeCloseTo(7, 12);
+        });
+        it("is locally isometric in every direction", () => {
+            const dev = new CylinderDevelopment(spec, tangentPlane);
+            const delta = 0.01;
+            for (const [dx, dy] of [[1, 0], [0, 1], [Math.SQRT1_2, Math.SQRT1_2]]) {
+                const a = dev.evalPoint(dev.toUV(new Point2D(5, 3)));
+                const b = dev.evalPoint(dev.toUV(new Point2D(5 + dx * delta, 3 + dy * delta)));
+                expect(a.distanceTo(b)).toBeCloseTo(delta, 6);
+            }
+        });
+        it("rejects a sketch plane perpendicular to the axis", () => {
+            const topPlane = new Plane(new Point(25, 0, 5), new Vector3d(1, 0, 0), new Vector3d(0, 0, 1));
+            expect(() => new CylinderDevelopment(spec, topPlane)).toThrow(/perpendicular to the target surface axis/);
+        });
+        it("rejects a sketch plane containing the axis", () => {
+            const radialPlane = new Plane(new Point(25, 0, 0), new Vector3d(1, 0, 0), new Vector3d(0, 1, 0));
+            expect(() => new CylinderDevelopment(spec, radialPlane)).toThrow(/must not contain the target surface axis/);
+        });
+        it("rejects a sketch plane origin on the axis", () => {
+            const centeredPlane = new Plane(new Point(0, 0, 0), new Vector3d(0, 1, 0), new Vector3d(1, 0, 0));
+            expect(() => new CylinderDevelopment(spec, centeredPlane)).toThrow(/must not lie on the target surface axis/);
+        });
+        it("measures distance to the surface", () => {
+            const dev = new CylinderDevelopment(spec, tangentPlane);
+            expect(dev.distanceTo(new Point(27, 0, 10))).toBeCloseTo(2, 12);
+            expect(dev.distanceTo(new Point(20, 0, -4))).toBeCloseTo(5, 12);
+        });
+    });
+    describe("cone", () => {
+        const semiAngle = Math.PI / 6;
+        const spec = {
+            origin: new Point(0, 0, 0),
+            axisDir: new Vector3d(0, 0, 1),
+            refRadius: 20,
+            semiAngle,
+        };
+        // Tangent plane at the anchor (20, 0, 0): local x is circumferential,
+        // local y follows the meridian (away from the apex).
+        const tangentPlane = new Plane(new Point(20, 0, 0), new Vector3d(0, 1, 0), new Vector3d(Math.cos(semiAngle), 0, -Math.sin(semiAngle)));
+        it("maps the sketch origin to its radial projection on the surface", () => {
+            const dev = new ConeDevelopment(spec, tangentPlane);
+            const uv = dev.toUV(new Point2D(0, 0));
+            expect(uv.u).toBeCloseTo(0, 12);
+            expect(uv.v).toBeCloseTo(0, 12);
+            const anchor = dev.evalPoint(uv);
+            expect(anchor.x).toBeCloseTo(20, 12);
+            expect(anchor.y).toBeCloseTo(0, 12);
+            expect(anchor.z).toBeCloseTo(0, 12);
+        });
+        it("preserves length along the meridian", () => {
+            const dev = new ConeDevelopment(spec, tangentPlane);
+            const point = dev.evalPoint(dev.toUV(new Point2D(0, 10)));
+            // 10 units along the meridian: radius grows by 10·sin(α), height by 10·cos(α).
+            const radial = Math.hypot(point.x, point.y);
+            expect(radial).toBeCloseTo(20 + 10 * Math.sin(semiAngle), 12);
+            expect(point.z).toBeCloseTo(10 * Math.cos(semiAngle), 12);
+            const anchor = dev.evalPoint(dev.toUV(new Point2D(0, 0)));
+            expect(anchor.distanceTo(point)).toBeCloseTo(10, 12);
+        });
+        it("is locally isometric in every direction", () => {
+            const dev = new ConeDevelopment(spec, tangentPlane);
+            const delta = 0.01;
+            for (const [dx, dy] of [[1, 0], [0, 1], [Math.SQRT1_2, -Math.SQRT1_2]]) {
+                const a = dev.evalPoint(dev.toUV(new Point2D(4, -2)));
+                const b = dev.evalPoint(dev.toUV(new Point2D(4 + dx * delta, -2 + dy * delta)));
+                expect(a.distanceTo(b)).toBeCloseTo(delta, 6);
+            }
+        });
+        it("normalizes a negative half-angle to the same surface", () => {
+            const flipped = new ConeDevelopment({ ...spec, semiAngle: -semiAngle }, tangentPlane);
+            const anchor = flipped.evalPoint(flipped.toUV(new Point2D(0, 0)));
+            expect(anchor.x).toBeCloseTo(20, 12);
+            expect(anchor.y).toBeCloseTo(0, 12);
+            expect(anchor.z).toBeCloseTo(0, 12);
+        });
+        it("rejects a sketch that reaches the apex", () => {
+            const dev = new ConeDevelopment(spec, tangentPlane);
+            // The apex develops to 40 units behind the anchor along the meridian.
+            expect(() => dev.toUV(new Point2D(0, -40))).toThrow(/apex/);
+        });
+        it("measures distance to the surface", () => {
+            const dev = new ConeDevelopment(spec, tangentPlane);
+            // Surface radius at z = 0 is 20; a point 2 beyond it sits at
+            // 2·cos(α) normal distance.
+            expect(dev.distanceTo(new Point(22, 0, 0))).toBeCloseTo(2 * Math.cos(semiAngle), 12);
+        });
+    });
+});

package/lib/dist/tests/features/wrap-extruded-target.test.d.ts

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

package/lib/dist/tests/features/wrap-extruded-target.test.js

@@ -0,0 +1,106 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import wrap from "../../core/wrap.js";
+import cylinder from "../../core/cylinder.js";
+import extrude from "../../core/extrude.js";
+import subtract from "../../core/subtract.js";
+import select from "../../core/select.js";
+import plane from "../../core/plane.js";
+import { circle, rect, text, vMove } from "../../core/2d/index.js";
+import { face } from "../../filters/index.js";
+import { ShapeProps } from "../../oc/props.js";
+// Extruded circle(50) (diameter) → cylinder R=25, z ∈ [0, 80]. Its lateral
+// face carries a reverse-parameterized surface (axis -z, flag REVERSED) —
+// wrap must still emboss away from the material.
+const BASE_VOLUME = Math.PI * 25 * 25 * 80;
+// Developed rect(20, 10) pad, thickness 1 outward: (s/R)/2 · ((R+t)² - R²) · h
+const PAD_OUT = ((20 / 25) / 2) * (26 * 26 - 25 * 25) * 10;
+// Same pocket cut 1 deep into the surface
+const PAD_IN = ((20 / 25) / 2) * (25 * 25 - 24 * 24) * 10;
+function extrudedCylinder() {
+    sketch("top", () => {
+        circle(50);
+    });
+    extrude(80);
+}
+function rectSketch() {
+    return sketch(plane("front", 30), () => {
+        vMove(20);
+        rect(20, 10);
+    });
+}
+function volumeOf(obj) {
+    return obj.getShapes().reduce((sum, shape) => sum + ShapeProps.getProperties(shape.getShape()).volumeMm3, 0);
+}
+function endFaceRadialDistances(w) {
+    return (w.getState("end-faces") || []).map(fc => {
+        const c = ShapeProps.getProperties(fc.getShape()).centroid;
+        return Math.round(Math.hypot(c.x, c.y) * 10) / 10;
+    });
+}
+describe("wrap on an extruded (reverse-parameterized) cylinder", () => {
+    setupOC();
+    it("embosses a rect pad outward", () => {
+        extrudedCylinder();
+        const s = rectSketch();
+        const f = select(face().cylinder());
+        const w = wrap(1, s, f);
+        const obj = w;
+        render();
+        expect(w.getError()).toBeNull();
+        expect(volumeOf(obj)).toBeCloseTo(BASE_VOLUME + PAD_OUT, 0);
+    });
+    it("places a standalone pad outside the surface", () => {
+        extrudedCylinder();
+        const s = rectSketch();
+        const f = select(face().cylinder());
+        const w = wrap(1, s, f).new();
+        const obj = w;
+        render();
+        expect(w.getError()).toBeNull();
+        // 204 only fits the outward shell (25..26); the inward one would be 196
+        expect(volumeOf(obj)).toBeCloseTo(PAD_OUT, 0);
+    });
+    it("engraves a pocket into the surface", () => {
+        extrudedCylinder();
+        const s = rectSketch();
+        const f = select(face().cylinder());
+        const w = wrap(1, s, f).remove();
+        render();
+        expect(w.getError()).toBeNull();
+        const total = volumeOf(w);
+        expect(total).toBeCloseTo(BASE_VOLUME - PAD_IN, 0);
+    });
+    it("embosses text decals outward (user repro)", () => {
+        extrudedCylinder();
+        const s = sketch(plane("front", 30), () => {
+            vMove(20);
+            text("hello world").align("center");
+        });
+        const f = select(face().cylinder());
+        const w = wrap(1, s, f).new();
+        const obj = w;
+        render();
+        expect(w.getError()).toBeNull();
+        const dists = endFaceRadialDistances(obj);
+        expect(dists.length).toBeGreaterThan(0);
+        // glyph end-face centroids sit just under R+1 = 26; buried glyphs would be ~24
+        for (const dist of dists) {
+            expect(dist).toBeGreaterThan(25.2);
+        }
+    });
+    it("embosses into a bore toward the axis", () => {
+        const c1 = cylinder(50, 80);
+        const c2 = cylinder(25, 100).translate(0, 0, -10);
+        subtract(c1, c2);
+        const s = rectSketch();
+        const f = select(face().cylinder(50));
+        const w = wrap(1, s, f);
+        const obj = w;
+        render();
+        expect(w.getError()).toBeNull();
+        const tubeVolume = Math.PI * (50 * 50 - 25 * 25) * 80;
+        expect(volumeOf(obj)).toBeCloseTo(tubeVolume + PAD_IN, 0);
+    });
+});

package/lib/dist/tests/features/wrap-repeat.test.d.ts

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