fluidcad 0.0.33 → 0.0.34

package/lib/dist/rendering/render.js

@@ -8,7 +8,12 @@ import { Mesh } from "../oc/mesh.js";
 import { Profiler } from "../common/profiler.js";
 import { describeError } from "../common/describe-error.js";
 export class SceneRenderer {
-    meshBuilder = new MeshBuilder();
+    meshConfig;
+    meshBuilder;
+    constructor(meshConfig) {
+        this.meshConfig = meshConfig;
+        this.meshBuilder = new MeshBuilder(meshConfig);
+    }
     render(scene) {
         const sceneObjects = scene.getAllSceneObjects();
         console.log("============ Rendering ==============", sceneObjects.length);
@@ -121,7 +126,7 @@ export class SceneRenderer {
         const compound = ShapeOps.makeCompoundRaw([...targets].map(s => s.getShape()));
         try {
             const t0 = performance.now();
-            Mesh.ensureTriangulated(compound);
+            Mesh.ensureTriangulated(compound, this.meshConfig);
             console.log(`Batched mesh: ${targets.size} shapes in ${(performance.now() - t0).toFixed(1)}ms`);
         }
         finally {

package/lib/dist/scene-manager.d.ts

@@ -1,5 +1,7 @@
 import { Scene } from "./rendering/scene.js";
 import { SceneRenderer } from "./rendering/render.js";
+import type { MeshConfig } from "./oc/mesh.js";
+import type { FluidCADOptions } from "./index.js";
 import type { ExportOptions } from "./io/file-export.js";
 import type { ShapeProperties } from "./oc/props.js";
 import type { FaceProperties } from "./oc/face-props.js";
@@ -10,7 +12,7 @@ declare class SceneManager {
     currentScene: Scene;
     currentFile: string;
     renderer: SceneRenderer;
-    constructor(rootPath: string);
+    constructor(rootPath: string, meshConfig: MeshConfig);
     setCurrentFile(filePath: string): void;
     startScene(): Scene;
     renderScene(scene: Scene): Scene;
@@ -26,7 +28,7 @@ declare class SceneManager {
     };
     hitTest(scene: Scene, shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): HitTestResult;
 }
-export declare function createManager(rootPath: string): SceneManager;
+export declare function createManager(rootPath: string, options?: FluidCADOptions): SceneManager;
 export declare function getCurrentScene(): Scene;
 export declare function getCurrentFile(): string;
 export declare function setCurrentFile(filePath: string): void;

package/lib/dist/scene-manager.js

@@ -1,6 +1,7 @@
 import { Scene } from "./rendering/scene.js";
 import { SceneRenderer } from "./rendering/render.js";
 import { SceneCompare } from "./rendering/scene-compare.js";
+import { DEFAULT_MESH_CONFIG } from "./oc/mesh.js";
 import { FileImport } from "./io/file-import.js";
 import { FileExport } from "./io/file-export.js";
 import { ShapeProps } from "./oc/props.js";
@@ -12,9 +13,10 @@ class SceneManager {
     rootPath;
     currentScene = new Scene();
     currentFile = '';
-    renderer = new SceneRenderer();
-    constructor(rootPath) {
+    renderer;
+    constructor(rootPath, meshConfig) {
         this.rootPath = rootPath;
+        this.renderer = new SceneRenderer(meshConfig);
     }
     setCurrentFile(filePath) {
         this.currentFile = filePath;
@@ -100,9 +102,15 @@ class SceneManager {
     }
 }
 let currentManager = null;
-export function createManager(rootPath) {
+function resolveMeshConfig(options) {
+    return {
+        linDefl: options?.mesh?.lineDeflection ?? DEFAULT_MESH_CONFIG.linDefl,
+        angDefl: options?.mesh?.angularDeflection ?? DEFAULT_MESH_CONFIG.angDefl,
+    };
+}
+export function createManager(rootPath, options) {
     console.log(`Creating SceneManager with root path: ${rootPath}`);
-    currentManager = new SceneManager(rootPath);
+    currentManager = new SceneManager(rootPath, resolveMeshConfig(options));
     return currentManager;
 }
 export function getCurrentScene() {

package/lib/dist/tests/features/2d/arc.test.js

@@ -36,6 +36,70 @@ describe("arc", () => {
             expect(arcEdges.length).toBeGreaterThan(0);
         });
     });
+    describe("clockwise arc with .cw()", () => {
+        it("should create a CW arc from start to end around a center point", () => {
+            sketch("xy", () => {
+                arc([0, 0], [20, 0]).center([10, 0]).cw();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a valid arc when chained from current position", () => {
+            sketch("xy", () => {
+                hLine(20);
+                arc([0, 0]).center([10, 0]).cw();
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("major arc with .major()", () => {
+        it("should create a major arc (>180°) from current position", () => {
+            sketch("xy", () => {
+                arc([30, 0]).radius(20).major();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a major arc with two explicit points", () => {
+            sketch("xy", () => {
+                arc([0, 0], [30, 0]).radius(20).major();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+        it("should create a CW major arc with negative radius and major", () => {
+            sketch("xy", () => {
+                arc([30, 0]).radius(-20).major();
+                line([0, 0]);
+            });
+            const e = extrude(10);
+            render();
+            expect(e.getShapes()).toHaveLength(1);
+            const solid = e.getShapes()[0];
+            const arcEdges = getEdgesByType(solid, "arc");
+            expect(arcEdges.length).toBeGreaterThan(0);
+        });
+    });
     describe("combined with lines", () => {
         it("should create a shape with straight and curved edges", () => {
             sketch("xy", () => {

package/lib/dist/tests/features/2d/back.test.js

@@ -2,8 +2,9 @@ import { describe, it, expect } from "vitest";
 import { setupOC, render } from "../../setup.js";
 import sketch from "../../../core/sketch.js";
 import extrude from "../../../core/extrude.js";
-import { move, hMove, back, rect } from "../../../core/2d/index.js";
+import { move, hMove, back, rect, hLine, vLine, tLine } from "../../../core/2d/index.js";
 import { ShapeOps } from "../../../oc/shape-ops.js";
+import { Edge } from "../../../common/edge.js";
 describe("back", () => {
     setupOC();
     it("should revert cursor to the previous position", () => {
@@ -57,4 +58,19 @@ describe("back", () => {
         const bbox = ShapeOps.getBoundingBox(e.getShapes()[0]);
         expect(bbox.minX).toBeCloseTo(40, 0);
     });
+    it("should restore the tangent to its prior value, not just the position", () => {
+        let t;
+        sketch("xy", () => {
+            hLine(10); // tangent (+1, 0), pos (10, 0)
+            vLine(10); // tangent (0, +1), pos (10, 10)
+            back(); // pos reverts to (10, 0); tangent should revert to (+1, 0)
+            t = tLine(5); // with restored tangent, this should go to (15, 0)
+        });
+        render();
+        const edges = t.getOwnShapes().filter((sh) => sh instanceof Edge);
+        expect(edges).toHaveLength(1);
+        const endPoint = edges[0].getLastVertex().toPoint();
+        expect(endPoint.x).toBeCloseTo(15, 1);
+        expect(endPoint.y).toBeCloseTo(0, 1);
+    });
 });

package/lib/dist/tests/features/2d/tarc.test.js

@@ -234,4 +234,161 @@ describe("tArc", () => {
             render();
         });
     });
+    describe("tangent arc from current position to target line (target)", () => {
+        it("should create a tangent arc from a horizontal line ending tangent to a vertical line", () => {
+            const s = sketch("xy", () => {
+                const v = vLine([200, 200], 100).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(v);
+            });
+            render();
+            const shapes = s.getShapes();
+            // hLine + tArc (guide excluded) = at least 2 edges
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should accept a qualified line target", () => {
+            const s = sketch("xy", () => {
+                const v = vLine([200, 200], 100).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(outside(v));
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should allow chaining geometry after the solved arc", () => {
+            const s = sketch("xy", () => {
+                const v = vLine([200, 200], 100).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(v);
+                vLine(40);
+            });
+            render();
+            const shapes = s.getShapes();
+            // chain continues — hLine + tArc + vLine
+            expect(shapes.length).toBeGreaterThanOrEqual(3);
+        });
+        it("default arc curves to the left of the start tangent", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-150, 100], 300).guide();
+                move([0, 0]);
+                vLine(80);
+                tArc(h);
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            // start tangent is +Y; "left" of +Y is -X. End vertex sits at negative x.
+            const endX = arcs[0].getLastVertex().toPoint().x;
+            expect(endX).toBeLessThan(0);
+        });
+        it(".flip() reverses the curve to the right of the start tangent", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-150, 100], 300).guide();
+                move([0, 0]);
+                vLine(80);
+                tArc(h).flip();
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            const endX = arcs[0].getLastVertex().toPoint().x;
+            expect(endX).toBeGreaterThan(0);
+        });
+        it("should reject circle targets", () => {
+            const s = sketch("xy", () => {
+                const c = circle([200, 80], 30).guide();
+                move([0, 0]);
+                hLine(100);
+                tArc(c);
+            });
+            render();
+            const children = s.getChildren();
+            const arc = children[children.length - 1];
+            expect(arc.getError()).toMatch(/only line targets are supported/);
+        });
+    });
+    describe("tangent arc with radius ending at intersection (radius, target)", () => {
+        it("should end at the intersection with a line target", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(60, h);
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            // End vertex must lie on the target line y = 100.
+            const endY = arcs[0].getLastVertex().toPoint().y;
+            expect(endY).toBeCloseTo(100, 6);
+        });
+        it("should end at the intersection with a circle target", () => {
+            const s = sketch("xy", () => {
+                // circle(diameter); 80 diameter = 40 radius
+                const c = circle([80, 0], 80).guide();
+                move([0, 0]);
+                hLine(40);
+                tArc(50, c);
+            });
+            render();
+            const arcs = getEdgesByType(s.getShapes(), "arc");
+            expect(arcs.length).toBe(1);
+            // End vertex must lie on the target circle (radius 40 from (80, 0)).
+            const end = arcs[0].getLastVertex().toPoint();
+            const dist = Math.hypot(end.x - 80, end.y - 0);
+            expect(dist).toBeCloseTo(40, 6);
+        });
+        it("negative radius flips the sweep direction", () => {
+            // Same line, same start, same tangent — only the sign of the radius
+            // differs. Positive radius (CCW) curves to the left of the tangent;
+            // negative radius (CW) curves to the right.
+            const sCCW = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(60, h);
+            });
+            render();
+            const sCW = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(-60, h);
+            });
+            render();
+            const ccwArc = getEdgesByType(sCCW.getShapes(), "arc")[0];
+            const cwArc = getEdgesByType(sCW.getShapes(), "arc")[0];
+            // T̂ = (0, +1); "left" of the tangent is −x, "right" is +x.
+            expect(ccwArc.getLastVertex().toPoint().x).toBeLessThan(0);
+            expect(cwArc.getLastVertex().toPoint().x).toBeGreaterThan(0);
+        });
+        it("should chain geometry after the solved arc", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-200, 100], 400).guide();
+                move([0, 0]);
+                vLine(50);
+                tArc(60, h);
+                hLine(40);
+            });
+            render();
+            const shapes = s.getShapes();
+            expect(shapes.length).toBeGreaterThanOrEqual(3);
+        });
+        it("should record an error when there is no intersection", () => {
+            const s = sketch("xy", () => {
+                const h = hLine([-200, 500], 400).guide();
+                move([0, 0]);
+                vLine(10);
+                tArc(20, h);
+            });
+            render();
+            const children = s.getChildren();
+            const arc = children[children.length - 1];
+            expect(arc.getError()).toMatch(/does not intersect target/);
+        });
+    });
 });

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

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

package/lib/dist/tests/features/repeat-user-repro.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import sketch from "../../core/sketch.js";
+import extrude from "../../core/extrude.js";
+import axis from "../../core/axis.js";
+import repeat from "../../core/repeat.js";
+import sweep from "../../core/sweep.js";
+import cut from "../../core/cut.js";
+import { rect, circle, vLine, tArc, tLine, slot, move, hMove } from "../../core/2d/index.js";
+import copy from "../../core/copy.js";
+import { countShapes } from "../utils.js";
+// Regression: a circular repeat whose axis is an AxisFromEdge derived from
+// a sketch line, whose targets are cuts on sketch-region slots. Exercises:
+//   - LazyMatrix.rotation with an unbuilt AxisObjectBase source
+//   - Extrude.getSourceDependencies pulling the containing Sketch into the
+//     clone set so Sketch.build's clone-mode path carries shapes for cloned
+//     geometry primitives (Slot here) that would otherwise lose their
+//     Sketch parent context after clone.
+describe("repeat circular with axis-from-sketch-line and cut-of-slot targets", () => {
+    setupOC();
+    it("renders without errors and produces the expected cut instances", () => {
+        const spine = sketch("front", () => {
+            vLine(1.5);
+            tArc(-4, 45);
+            const topSegment = tLine(1.5);
+            return { topSegment };
+        }).reusable();
+        const profile = sketch("top", () => {
+            const innerPipe = circle(1.5);
+            const outerPipe = circle(2);
+            return { innerPipe, outerPipe };
+        });
+        const pipe = sweep(spine, profile.regions.outerPipe);
+        sketch("top", () => {
+            rect(3.5).centered().radius(0.5);
+            move([-2.5 / 2, -2.5 / 2]);
+            const c = circle(0.5);
+            copy("circular", [0, 0], { count: 4, angle: 360 }, c);
+        });
+        extrude(0.375);
+        sketch(pipe.endFaces(), () => {
+            circle(4);
+        });
+        const upperFlange = extrude(-0.625);
+        sweep(spine, profile.regions.innerPipe).remove();
+        const slots = sketch(upperFlange.endFaces(), () => {
+            hMove(3.25 / 2);
+            const outerSlot = slot(1, 0.75 / 2);
+            const innerSlot = slot(1, 0.45 / 2);
+            return { outerSlot, innerSlot };
+        });
+        const s1 = cut(slots.regions.innerSlot);
+        const s2 = cut(0.25, slots.regions.outerSlot);
+        const a = axis(spine.regions.topSegment);
+        repeat("circular", a, { count: 4, angle: 360 }, s1, s2);
+        const scene = render();
+        expect(countShapes(scene)).toBeGreaterThan(0);
+        expect(scene.getAllSceneObjects().some(o => o.getError())).toBe(false);
+    });
+});

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

@@ -6,6 +6,7 @@ import shell from "../../core/shell.js";
 import select from "../../core/select.js";
 import cylinder from "../../core/cylinder.js";
 import { rect } from "../../core/2d/index.js";
+import { Shell } from "../../features/shell.js";
 import { countShapes } from "../utils.js";
 import { ShapeProps } from "../../oc/props.js";
 import { face } from "../../filters/index.js";
@@ -198,6 +199,41 @@ describe("shell", () => {
             expect(first.getShapes()[0].isSame(allShapes[0])).toBe(true);
         });
     });
+    describe("join type", () => {
+        const buildShelledBox = (apply) => {
+            sketch("xy", () => {
+                rect(100, 100);
+            });
+            extrude(50);
+            select(face().onPlane("xy", 50));
+            const s = shell(5);
+            apply(s);
+            const scene = render();
+            return scene.getAllSceneObjects()
+                .flatMap(o => o.getShapes())
+                .find(sh => sh.getType() === "solid");
+        };
+        it("should produce a valid solid with default join type (arc)", () => {
+            const solid = buildShelledBox(() => { });
+            expect(solid).toBeDefined();
+            expect(ShapeProps.getProperties(solid.getShape()).volumeMm3).toBeGreaterThan(0);
+        });
+        it("should produce a valid solid with join('intersection')", () => {
+            const solid = buildShelledBox(s => s.join('intersection'));
+            expect(solid).toBeDefined();
+            expect(ShapeProps.getProperties(solid.getShape()).volumeMm3).toBeGreaterThan(0);
+        });
+        it("should produce a valid solid with join('tangent')", () => {
+            const solid = buildShelledBox(s => s.join('tangent'));
+            expect(solid).toBeDefined();
+            expect(ShapeProps.getProperties(solid.getShape()).volumeMm3).toBeGreaterThan(0);
+        });
+        it("should treat shells with different join types as not equal", () => {
+            const a = new Shell(5);
+            const b = new Shell(5).join('intersection');
+            expect(a.compareTo(b)).toBe(false);
+        });
+    });
     describe("shell with multiple selections", () => {
         it("should shell a box by removing two faces", () => {
             sketch("xy", () => {

package/lib/dist/tests/global-setup.js

@@ -1,5 +1,6 @@
 import { beforeAll } from "vitest";
 import { init } from "../index.js";
 beforeAll(async () => {
-    await init("/tmp/fluidcad-test");
+    process.env.FLUIDCAD_WORKSPACE_PATH = "/tmp/fluidcad-test";
+    await init();
 });

package/lib/dist/tests/helpers/extract-blocks.d.ts

@@ -0,0 +1,9 @@
+export type FluidBlock = {
+    /** Path relative to the docs root, forward-slash. */
+    file: string;
+    /** 1-based line number where the block body starts (the line after the opening fence). */
+    line: number;
+    /** Block body — no fences. */
+    block: string;
+};
+export declare function extractFluidJsBlocks(docsRootRel: string): FluidBlock[];

package/lib/dist/tests/helpers/extract-blocks.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import path from "path";
+const FENCE_RE = /^(\s*)```([A-Za-z0-9_.-]*)\s*$/;
+const RUNNABLE_LANGS = new Set(["fluid.js", "fluid", "fluidjs"]);
+function listMarkdown(dir) {
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_")) {
+            continue;
+        }
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...listMarkdown(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+function extractFromFile(file, docsRoot) {
+    const text = fs.readFileSync(file, "utf8");
+    const lines = text.split("\n");
+    const rel = path.relative(docsRoot, file).split(path.sep).join("/");
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const openMatch = lines[i].match(FENCE_RE);
+        if (!openMatch || !RUNNABLE_LANGS.has(openMatch[2])) {
+            i++;
+            continue;
+        }
+        const startLine = i + 2;
+        const body = [];
+        i++;
+        while (i < lines.length) {
+            const closeMatch = lines[i].match(FENCE_RE);
+            if (closeMatch && closeMatch[2] === "") {
+                break;
+            }
+            body.push(lines[i]);
+            i++;
+        }
+        blocks.push({ file: rel, line: startLine, block: body.join("\n") });
+        i++;
+    }
+    return blocks;
+}
+export function extractFluidJsBlocks(docsRootRel) {
+    const docsRoot = path.resolve(docsRootRel);
+    const blocks = [];
+    for (const file of listMarkdown(docsRoot).sort()) {
+        blocks.push(...extractFromFile(file, docsRoot));
+    }
+    return blocks;
+}

package/lib/dist/tests/llm-docs-examples.test.d.ts

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

package/lib/dist/tests/llm-docs-examples.test.js

@@ -0,0 +1,62 @@
+// Runs every fluid.js fenced block in llm-docs/**/*.md against the real
+// FluidCAD runtime and asserts the scene compiles and produces ≥1 rendered
+// object. Catches three classes of doc rot:
+//
+//   1. Syntax errors in examples (renamed args, dropped commas, etc.).
+//   2. API drift — an example calls a method that no longer exists.
+//   3. Geometry-empty examples — the snippet runs but yields nothing visible,
+//      which usually means the user-facing intent broke.
+//
+// The runner reuses the global OCC init from global-setup.ts and the
+// startScene/render plumbing from setup.ts, so it sits on the same OCC
+// initialisation the rest of the test suite uses.
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "./setup.js";
+import { extractFluidJsBlocks } from "./helpers/extract-blocks.js";
+import * as core from "../core/index.js";
+import * as filters from "../filters/index.js";
+import * as constraints from "../features/2d/constraints/geometry-qualifier.js";
+import * as math from "../math/index.js";
+import { countShapes } from "./utils.js";
+function buildGlobals() {
+    return {
+        ...core,
+        ...filters,
+        ...constraints,
+        ...math,
+    };
+}
+// Doc examples often show the `import { foo } from "fluidcad/..."` line a
+// real user would write at the top of a .fluid.js file. The runner injects
+// every public export as a Function() parameter, so those imports are dead
+// weight here — and `new Function` can't parse them anyway. Strip them out
+// before executing.
+const IMPORT_LINE_RE = /^\s*import\s[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm;
+function stripImports(block) {
+    return block.replace(IMPORT_LINE_RE, "");
+}
+function runBlock(block, file, line) {
+    const globals = buildGlobals();
+    const paramNames = Object.keys(globals);
+    const paramValues = paramNames.map((n) => globals[n]);
+    const wrapped = `"use strict";\n${stripImports(block)}\n//# sourceURL=llm-docs/${file}:${line}`;
+    const fn = new Function(...paramNames, wrapped);
+    fn(...paramValues);
+}
+const blocks = extractFluidJsBlocks("llm-docs");
+describe("llm-docs fluid.js examples", () => {
+    setupOC();
+    if (blocks.length === 0) {
+        it("found at least one fluid.js block", () => {
+            expect(blocks.length).toBeGreaterThan(0);
+        });
+        return;
+    }
+    for (const { file, line, block } of blocks) {
+        it(`${file}:${line} compiles and produces ≥1 rendered object`, () => {
+            runBlock(block, file, line);
+            const scene = render();
+            expect(countShapes(scene)).toBeGreaterThan(0);
+        });
+    }
+});

package/lib/dist/tests/setup.js

@@ -1,7 +1,8 @@
 import { beforeEach } from "vitest";
 import { getSceneManager, getCurrentScene } from "../scene-manager.js";
 import { SceneRenderer } from "../rendering/render.js";
-const renderer = new SceneRenderer();
+import { DEFAULT_MESH_CONFIG } from "../oc/mesh.js";
+const renderer = new SceneRenderer(DEFAULT_MESH_CONFIG);
 export function setupOC() {
     beforeEach(() => {
         getSceneManager().startScene();