fluidcad 0.0.33 → 0.0.35

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

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

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

@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import { setupOC, render } from "../setup.js";
+import { getSceneManager } from "../../scene-manager.js";
+import { SceneCompare } from "../../rendering/scene-compare.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 remove from "../../core/remove.js";
+import { rect, circle, vLine, tArc, tLine, slot, move, hMove } from "../../core/2d/index.js";
+import copy from "../../core/copy.js";
+// Regression: re-rendering a scene whose `repeat("circular", ...)` axis is an
+// AxisFromEdge derived from a sketch line used to crash inside
+// SceneCompare.compare with "Cannot read properties of undefined (reading
+// 'origin')". RepeatCircular.compareTo eagerly called getAxis() on the
+// new-scene axis source, which hadn't been built yet (compare runs pre-render).
+describe("repeat circular cache-compare on unbuilt axis source", () => {
+    setupOC();
+    function buildScene(includeRemove) {
+        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);
+        if (includeRemove) {
+            remove(spine);
+        }
+    }
+    function currentScene() {
+        const mgr = getSceneManager();
+        if (!mgr) {
+            throw new Error("Scene manager not initialized");
+        }
+        return mgr.currentScene;
+    }
+    function startNewScene() {
+        const mgr = getSceneManager();
+        if (!mgr) {
+            throw new Error("Scene manager not initialized");
+        }
+        return mgr.startScene();
+    }
+    it("re-parsing the same script with cache compare does not throw", () => {
+        buildScene(false);
+        render();
+        const previousScene = currentScene();
+        expect(previousScene.getAllSceneObjects().some(o => o.getError())).toBe(false);
+        const newScene = startNewScene();
+        buildScene(false);
+        SceneCompare.compare(previousScene, newScene);
+        const rendered = render();
+        const errored = rendered.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getUniqueType()}: ${o.getError()}`)).toEqual([]);
+    });
+    it("appending remove(spine) after a cached render does not throw", () => {
+        buildScene(false);
+        render();
+        const previousScene = currentScene();
+        const newScene = startNewScene();
+        buildScene(true);
+        SceneCompare.compare(previousScene, newScene);
+        const rendered = render();
+        const errored = rendered.getAllSceneObjects().filter(o => o.getError());
+        expect(errored.map(o => `${o.getUniqueType()}: ${o.getError()}`)).toEqual([]);
+    });
+});

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();